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