public void Execute_ManyTimes_Performances(int count)
{
var rows = new List <object[]>();
for (int i = 0; i < count; i++)
{
rows.Add(new object[] { i, i + 1 });
}
var args = new ObjectsResultSetResolverArgs(rows.ToArray());
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "a";
rs.Columns[1].ColumnName = "b";
var stopWatch = new Stopwatch();
stopWatch.Start();
var extender = new NCalcExtendEngine(
new ServiceLocator(),
new Context(null),
new ColumnNameIdentifier("c"),
"[b] - [a] + Max(a,b) - Sin(a)"
);
var newRs = extender.Execute(rs);
stopWatch.Stop();
Assert.That(stopWatch.ElapsedMilliseconds, Is.LessThanOrEqualTo(5000));
}
public void Execute_TwoCustomColumns_ThreeGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1d, 10 }, new object[] { "alpha", 1, 20 }, new object[] { "beta", 2, 30 }, new object[] { "alpha", 2, 40 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "first";
rs.Columns[1].ColumnName = "second";
rs.Columns[1].SetOrdinal(0);
var settings = new SettingsNameResultSet(new List <IColumnDefinition>()
{
new Column()
{
Identifier = new ColumnNameIdentifier("first"), Role = ColumnRole.Key, Type = ColumnType.Text
},
new Column()
{
Identifier = new ColumnNameIdentifier("second"), Role = ColumnRole.Key, Type = ColumnType.Numeric
},
}
);
var grouping = new NameByColumnGrouping(settings);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(3));
Assert.That(result[new KeyCollection(new object[] { "alpha", 1m })].Rows, Has.Count.EqualTo(2));
Assert.That(result[new KeyCollection(new object[] { "alpha", 2m })].Rows, Has.Count.EqualTo(1));
Assert.That(result[new KeyCollection(new object[] { "beta", 2m })].Rows, Has.Count.EqualTo(1));
}
public void Execute_StandardRsColumnNameAndVariable_CorrectExtension()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "Alpha", 1, 2 }, new object[] { "Beta", 3, 2 }, new object[] { "Gamma", 5, 7 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "a";
rs.Columns[1].ColumnName = "b";
rs.Columns[2].ColumnName = "c";
var extender = new NCalcExtendEngine(
new ServiceLocator(),
new Context(new Dictionary <string, ITestVariable> {
{ "myVar", new GlobalVariable(new LiteralScalarResolver <decimal>(2)) }
}),
new ColumnNameIdentifier("d"),
"[@myVar] * [b] * [c]"
);
var newRs = extender.Execute(rs);
Assert.That(newRs.Columns.Count, Is.EqualTo(4));
Assert.That(newRs.Columns[3].ColumnName, Is.EqualTo("d"));
Assert.That(newRs.Rows[0][3], Is.EqualTo(4));
Assert.That(newRs.Rows[1][3], Is.EqualTo(12));
Assert.That(newRs.Rows[2][3], Is.EqualTo(70));
}
public void Execute_TwoCustomColumns_ThreeGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1d, 10 }, new object[] { "alpha", 1, 20 }, new object[] { "beta", 2, 30 }, new object[] { "alpha", 2, 40 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var settings = new SettingsOrdinalResultSet(new List <IColumnDefinition>()
{
new Column()
{
Identifier = new ColumnOrdinalIdentifier(0), Role = ColumnRole.Key, Type = ColumnType.Text
},
new Column()
{
Identifier = new ColumnOrdinalIdentifier(1), Role = ColumnRole.Key, Type = ColumnType.Numeric
},
}
);
var grouping = new OrdinalColumnGrouping(settings, Context.None);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(3));
Assert.That(result[new KeyCollection(new object[] { "alpha", 1m })].Rows, Has.Count.EqualTo(2));
Assert.That(result[new KeyCollection(new object[] { "alpha", 2m })].Rows, Has.Count.EqualTo(1));
Assert.That(result[new KeyCollection(new object[] { "beta", 2m })].Rows, Has.Count.EqualTo(1));
}
public void Execute_StandardRsColumnNameAndVariableFirstArg_CorrectExtension()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "Alpha", 1, 2 }, new object[] { "Beta", 3, 2 }, new object[] { "Gamma", 5, 7 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "a";
rs.Columns[1].ColumnName = "b";
rs.Columns[2].ColumnName = "c";
var extender = new NativeExtendEngine(
new ServiceLocator(),
new Context(new Dictionary <string, ITestVariable> {
{ "myVar", new GlobalVariable(new LiteralScalarResolver <string>("foo")) }
}),
new ColumnNameIdentifier("d"),
"@myVar | text-to-first-chars(#1) | text-to-upper"
);
var newRs = extender.Execute(rs);
Assert.That(newRs.Columns.Count, Is.EqualTo(4));
Assert.That(newRs.Columns[3].ColumnName, Is.EqualTo("d"));
Assert.That(newRs.Rows[0][3], Is.EqualTo("F"));
Assert.That(newRs.Rows[1][3], Is.EqualTo("FOO"));
Assert.That(newRs.Rows[2][3], Is.EqualTo("FOO"));
}
private NBi.Core.ResultSet.ResultSet Build()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1 }, new object[] { "alpha", 2 }, new object[] { "beta", 3 }, new object[] { "alpha", 4 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "keyColumn";
rs.Columns[1].ColumnName = "valueColumn";
return(rs);
}
public void Execute_RowCountEmptyResultSet_CorrectResult()
{
var rsArgs = new ObjectsResultSetResolverArgs(
new List <object[]>()
{
});
var args = new RowCountResultSetScalarResolverArgs(rsArgs);
var resolver = new ProjectionResultSetScalarResolver <int>(args);
Assert.That(resolver.Execute(), Is.EqualTo(0));
}
public void Execute_NotExistingColumnFailureStrategy_IgnoreIssue()
{
var args = new ObjectsResultSetResolverArgs(new[] { new[] { "100,12", "Alpha" }, new[] { "100", "Beta" }, new[] { "0,1", "Gamma" } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var renamer = new NewNameRenamingEngine(
new ColumnNameIdentifier("unexistingColumn"),
new LiteralScalarResolver <string>("myNewName")
);
Assert.Throws <NBiException>(() => renamer.Execute(rs));
}
public void Execute_ExistingColumnByOrdinal_ColumnRenamed()
{
var args = new ObjectsResultSetResolverArgs(new[] { new[] { "100,12", "Alpha" }, new[] { "100", "Beta" }, new[] { "0,1", "Gamma" } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var renamer = new NewNameRenamingEngine(
new ColumnOrdinalIdentifier(1),
new LiteralScalarResolver <string>("myNewName")
);
var newRs = renamer.Execute(rs);
Assert.That(newRs.Columns[1].ColumnName, Is.EqualTo("myNewName"));
}
public void Execute_RowCount_CorrectResult()
{
var rsArgs = new ObjectsResultSetResolverArgs(
new List <object[]>()
{
new object[] { "alpha", 1 },
new object[] { "beta", 2 },
new object[] { "Gamma", 3 }
});
var args = new RowCountResultSetScalarResolverArgs(rsArgs);
var resolver = new ProjectionResultSetScalarResolver <int>(args);
Assert.That(resolver.Execute(), Is.EqualTo(3));
}
public void Execute_SingleColumn_TwoGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1 }, new object[] { "alpha", 2 }, new object[] { "beta", 3 }, new object[] { "alpha", 4 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var settings = new SettingsOrdinalResultSet(KeysChoice.First, ValuesChoice.None, NumericAbsoluteTolerance.None);
var grouping = new OrdinalColumnGrouping(settings, Context.None);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(2));
Assert.That(result[new KeyCollection(new[] { "alpha" })].Rows, Has.Count.EqualTo(3));
Assert.That(result[new KeyCollection(new[] { "beta" })].Rows, Has.Count.EqualTo(1));
}
public void Execute_NotExistingColumnSkipStrategy_IgnoreIssue()
{
var args = new ObjectsResultSetResolverArgs(new[] { new[] { "100,12", "Alpha" }, new[] { "100", "Beta" }, new[] { "0,1", "Gamma" } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var renamer = new NewNameRenamingEngine(
new ColumnNameIdentifier("unexistingColumn"),
new LiteralScalarResolver <string>("myNewName"),
new SkipAlterationStrategy()
);
var newRs = renamer.Execute(rs);
Assert.That(newRs.Columns.Cast <DataColumn>().Any(c => c.ColumnName == "unexistingColumn"), Is.False);
}
public void Execute_SingleColumn_TwoGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1 }, new object[] { "beta", 2 }, new object[] { "BETA", 3 }, new object[] { "alpha", 4 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var lowerCase = new SinglePredication(new TextLowerCase(false), new ColumnOrdinalIdentifier(0));
var upperCase = new SinglePredication(new TextUpperCase(false), new ColumnOrdinalIdentifier(0));
var grouping = new CaseGrouping(new IPredication[] { lowerCase, upperCase }, Context.None);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(2));
Assert.That(result.ElementAt(0).Value.Rows, Has.Count.EqualTo(3));
Assert.That(result.ElementAt(1).Value.Rows, Has.Count.EqualTo(1));
}
public void Execute_TwoColumns_ThreeGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", "1", 10 }, new object[] { "alpha", "1", 20 }, new object[] { "beta", "2", 30 }, new object[] { "alpha", "2", 40 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var settings = new SettingsOrdinalResultSet(KeysChoice.AllExpectLast, ValuesChoice.None, NumericAbsoluteTolerance.None);
var grouping = new OrdinalByColumnGrouping(settings);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(3));
Assert.That(result[new KeyCollection(new object[] { "alpha", "1" })].Rows, Has.Count.EqualTo(2));
Assert.That(result[new KeyCollection(new object[] { "alpha", "2" })].Rows, Has.Count.EqualTo(1));
Assert.That(result[new KeyCollection(new object[] { "beta", "2" })].Rows, Has.Count.EqualTo(1));
}
public void Execute_Top2None_ResultSetReduced()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1 }, new object[] { "alpha", 2 }, new object[] { "beta", 3 }, new object[] { "alpha", 4 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var filter = new TopRanking(2, new ColumnOrdinalIdentifier(1), ColumnType.Numeric);
var rankingByGroup = new GroupByFilter(filter, new NoneGrouping());
var result = rankingByGroup.Apply(rs);
Assert.That(result.Table.Rows, Has.Count.EqualTo(2));
Assert.That(result.Table.Rows.Cast <DataRow>().Where(x => x[0].ToString() == "alpha").Count(), Is.EqualTo(1));
Assert.That(result.Table.Rows.Cast <DataRow>().Where(x => x[0].ToString() == "beta").Count(), Is.EqualTo(1));
}
public void Apply_Rows_Success(object[] values, ColumnType columnType, int index)
{
var i = 0;
var objs = values.Select(x => new object[] { ++i, x }).ToArray();
var args = new ObjectsResultSetResolverArgs(objs);
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var ranking = new BottomRanking(new ColumnOrdinalIdentifier(1), columnType, null, null);
var filteredRs = ranking.Apply(rs);
Assert.That(filteredRs.Rows.Count, Is.EqualTo(1));
Assert.That(filteredRs.Rows[0].ItemArray[0], Is.EqualTo(index.ToString()));
Assert.That(filteredRs.Rows[0].ItemArray[1], Is.EqualTo(values.Min()));
}
public void Execute_ExistingColumnByName_ColumnRenamed()
{
var args = new ObjectsResultSetResolverArgs(new[] { new[] { "100,12", "Alpha" }, new[] { "100", "Beta" }, new[] { "0,1", "Gamma" } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[1].ColumnName = "myOldName";
var renamer = new NewNameRenamingEngine(
new ColumnNameIdentifier("myOldName"),
new LiteralScalarResolver <string>("myNewName")
);
var newRs = renamer.Execute(rs);
Assert.That(newRs.Columns[1].ColumnName, Is.EqualTo("myNewName"));
Assert.That(newRs.Columns.Cast <DataColumn>().Any(c => c.ColumnName == "myOldName"), Is.False);
}
private NBi.Core.ResultSet.ResultSet BuildLarge(int count)
{
var values = new List <object>();
for (int i = 0; i < count; i++)
{
values.Add(new object[] { i % 2 == 0 ? "alpha" : "beta", 1 });
}
var args = new ObjectsResultSetResolverArgs(values);
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "keyColumn";
rs.Columns[1].ColumnName = "valueColumn";
return(rs);
}
public void Apply_Alias_Success(object[] values, ColumnType columnType, int index)
{
var i = 0;
var objs = values.Select(x => new object[] { ++i, x }).ToArray();
var args = new ObjectsResultSetResolverArgs(objs);
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var alias = Mock.Of <IColumnAlias>(x => x.Column == 1 && x.Name == "myValue");
var ranking = new BottomRanking(new ColumnNameIdentifier("myValue"), columnType, Enumerable.Repeat(alias, 1), null);
var filteredRs = ranking.Apply(rs);
Assert.That(filteredRs.Rows.Count, Is.EqualTo(1));
Assert.That(filteredRs.Rows[0].ItemArray[0], Is.EqualTo(index.ToString()));
Assert.That(filteredRs.Rows[0].ItemArray[1], Is.EqualTo(values.Min()));
}
public void Apply_TopTwo_Success(object[] values, ColumnType columnType, int[] index)
{
var i = 0;
var objs = values.Select(x => new object[] { ++i, x }).ToArray();
var args = new ObjectsResultSetResolverArgs(objs);
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var ranking = new TopRanking(2, new ColumnOrdinalIdentifier(1), columnType, null, null);
var filteredRs = ranking.Apply(rs);
Assert.That(filteredRs.Rows.Count, Is.EqualTo(2));
Assert.That(filteredRs.Rows[0].ItemArray[0], Is.EqualTo(index[0]));
Assert.That(filteredRs.Rows[0].ItemArray[1], Is.EqualTo(values.Max()));
Assert.That(filteredRs.Rows[1].ItemArray[0], Is.EqualTo(index[1]));
Assert.That(filteredRs.Rows[1].ItemArray[1], Is.EqualTo(values.Except(Enumerable.Repeat(values.Max(), 1)).Max()));
}
public void Execute_Top2OneKey_ResultSetReduced()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1 }, new object[] { "alpha", 2 }, new object[] { "beta", 3 }, new object[] { "alpha", 4 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var settings = new SettingsOrdinalResultSet(KeysChoice.First, ValuesChoice.None, NumericAbsoluteTolerance.None);
var grouping = new OrdinalColumnGrouping(settings, Context.None);
var filter = new TopRanking(2, new ColumnOrdinalIdentifier(1), ColumnType.Numeric);
var rankingByGroup = new GroupByFilter(filter, grouping);
var result = rankingByGroup.Apply(rs);
Assert.That(result.Table.Rows, Has.Count.EqualTo(3));
Assert.That(result.Table.Rows.Cast <DataRow>().Where(x => x[0].ToString() == "alpha").Count(), Is.EqualTo(2));
Assert.That(result.Table.Rows.Cast <DataRow>().Where(x => x[0].ToString() == "beta").Count(), Is.EqualTo(1));
}
public void Execute_StandardRsColumnOrdinal_CorrectExtension()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "Alpha", 1, 2 }, new object[] { "Beta", 3, 2 }, new object[] { "Gamma", 5, 7 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var extender = new NCalcExtendEngine(
new ServiceLocator(),
new Context(null),
new ColumnOrdinalIdentifier(3),
"[#1] * [#2]"
);
var newRs = extender.Execute(rs);
Assert.That(newRs.Columns.Count, Is.EqualTo(4));
Assert.That(newRs.Rows[0][3], Is.EqualTo(2));
Assert.That(newRs.Rows[1][3], Is.EqualTo(6));
Assert.That(newRs.Rows[2][3], Is.EqualTo(35));
}
public void Apply_Exp_Success(object[] values, ColumnType columnType, int index)
{
var i = 0;
var objs = values.Select(x => new object[] { ++i, x }).ToArray();
var args = new ObjectsResultSetResolverArgs(objs);
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var alias = Mock.Of <IColumnAlias>(x => x.Column == 1 && x.Name == "myValue");
var exp = Mock.Of <IColumnExpression>(x => x.Name == "exp" && x.Value == "myValue % 10");
var ranking = new TopRanking(new ColumnNameIdentifier("exp"), columnType, Enumerable.Repeat(alias, 1), Enumerable.Repeat(exp, 1));
var filteredRs = ranking.Apply(rs);
Assert.That(filteredRs.Rows.Count, Is.EqualTo(1));
Assert.That(filteredRs.Rows[0].ItemArray[0], Is.EqualTo(index));
Assert.That(filteredRs.Rows[0].ItemArray[1], Is.EqualTo("139"));
}
public void Execute_TwoColumns_ThreeGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", "1", 10 }, new object[] { "ALPHA", "1", 20 }, new object[] { "beta", "2", 30 }, new object[] { "ALPHA", "2", 40 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var lowerCase = new SinglePredication(new TextLowerCase(false), new ColumnOrdinalIdentifier(0));
var upperCase = new AndCombinationPredication(new List <IPredication>()
{
new SinglePredication(new TextUpperCase(false), new ColumnOrdinalIdentifier(0)),
new SinglePredication(new TextEqual(false, new LiteralScalarResolver <string>("1")), new ColumnOrdinalIdentifier(1)),
});
var grouping = new CaseGrouping(new IPredication[] { lowerCase, upperCase }, Context.None);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(3));
Assert.That(result.ElementAt(0).Value.Rows, Has.Count.EqualTo(2));
Assert.That(result.ElementAt(1).Value.Rows, Has.Count.EqualTo(1));
Assert.That(result.ElementAt(2).Value.Rows, Has.Count.EqualTo(1));
}
public void Execute_MiddleColumnIsText_MiddleColumnIsNumeric()
{
var args = new ObjectsResultSetResolverArgs(new[] { new[] { "Alpha", "100,12", "true" }, new[] { "Beta", "100", "false" }, new[] { "Gamma", "N/A", "false" } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var factory = new ConverterFactory();
var converter = factory.Instantiate("text", "numeric", null, "fr-fr");
Assert.That(converter, Is.Not.Null);
Assert.That(converter, Is.TypeOf <TextToNumericConverter>());
var engine = new ConverterEngine("#1", converter);
engine.Execute(rs);
Assert.That(rs.Columns[1].DataType, Is.EqualTo(typeof(decimal)));
Assert.That(rs.Columns.Count, Is.EqualTo(3));
Assert.That(rs.Rows[0][1], Is.EqualTo(100.12));
Assert.That(rs.Rows[1][1], Is.EqualTo(100));
Assert.That(rs.Rows[2][1], Is.EqualTo(DBNull.Value));
}
public void Execute_MiddleColumnIsTextualDate_MiddleColumnIsDate()
{
var args = new ObjectsResultSetResolverArgs(new[] { new[] { "Alpha", "06/01/2018", "true" }, new[] { "Beta", "17/12/2015", "false" }, new[] { "Gamma", "Before 2014", "false" } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
var factory = new ConverterFactory();
var converter = factory.Instantiate("text", "date", new DateTime(2013, 1, 1), "fr-fr");
Assert.That(converter, Is.Not.Null);
Assert.That(converter, Is.TypeOf <TextToDateConverter>());
var engine = new ConverterEngine("#1", converter);
engine.Execute(rs);
Assert.That(rs.Columns[1].DataType, Is.EqualTo(typeof(DateTime)));
Assert.That(rs.Columns.Count, Is.EqualTo(3));
Assert.That(rs.Rows[0][1], Is.EqualTo(new DateTime(2018, 1, 6)));
Assert.That(rs.Rows[1][1], Is.EqualTo(new DateTime(2015, 12, 17)));
Assert.That(rs.Rows[2][1], Is.EqualTo(new DateTime(2013, 1, 1)));
}
public void Execute_StandardRsColumnName_CorrectExtension()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "Alpha", 1, 2 }, new object[] { "Beta", 3, 2 }, new object[] { "Gamma", 5, 7 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "a";
rs.Columns[1].ColumnName = "b";
rs.Columns[2].ColumnName = "c";
var extender = new NativeExtendEngine(
new ServiceLocator(),
new Context(null),
new ColumnNameIdentifier("d"),
"[a] | text-to-first-chars([c]) | text-to-upper"
);
var newRs = extender.Execute(rs);
Assert.That(newRs.Columns.Count, Is.EqualTo(4));
Assert.That(newRs.Columns[3].ColumnName, Is.EqualTo("d"));
Assert.That(newRs.Rows[0][3], Is.EqualTo("AL"));
Assert.That(newRs.Rows[1][3], Is.EqualTo("BE"));
Assert.That(newRs.Rows[2][3], Is.EqualTo("GAMMA"));
}
public void Execute_SingleColumn_TwoGroups()
{
var args = new ObjectsResultSetResolverArgs(new[] { new object[] { "alpha", 1 }, new object[] { "alpha", 2 }, new object[] { "beta", 3 }, new object[] { "alpha", 4 } });
var resolver = new ObjectsResultSetResolver(args);
var rs = resolver.Execute();
rs.Columns[0].ColumnName = "first";
var settings = new SettingsNameResultSet(new List <IColumnDefinition>()
{
new Column()
{
Identifier = new ColumnNameIdentifier("first"), Role = ColumnRole.Key, Type = ColumnType.Text
},
}
);
var grouping = new NameByColumnGrouping(settings);
var result = grouping.Execute(rs);
Assert.That(result, Has.Count.EqualTo(2));
Assert.That(result[new KeyCollection(new[] { "alpha" })].Rows, Has.Count.EqualTo(3));
Assert.That(result[new KeyCollection(new[] { "beta" })].Rows, Has.Count.EqualTo(1));
}
