public void AccessorCreatesNewObjectsThroughSlotBinding()
{
DataSource source = new DataSource("data");
source.AddDataSet(new ItemSequenceDataSet(new IDataItem[] { new ListDataItem <object>(new object[] { 42, typeof(int) }, null, false) }, 2));
IDataSourceResolver resolver = Mocks.StrictMock <IDataSourceResolver>();
using (Mocks.Record())
{
Expect.Call(resolver.ResolveDataSource("data")).Repeat.Twice().Return(source);
}
using (Mocks.Playback())
{
ITypeInfo type = Reflector.Wrap(typeof(Holder <>));
IConstructorInfo constructor = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
ISlotInfo valueSlot = constructor.Parameters[0];
ISlotInfo typeSlot = (IGenericParameterInfo)type.GenericArguments[0];
DataBindingContext context = new DataBindingContext(new NullConverter());
ObjectDataBinder binder = new ObjectDataBinder(type);
binder.SetSlotBinder(valueSlot, new ScalarDataBinder(new DataBinding(0, null), "data"));
binder.SetSlotBinder(typeSlot, new ScalarDataBinder(new DataBinding(1, null), "data"));
IDataAccessor accessor = binder.Register(context, resolver);
List <IDataItem> items = new List <IDataItem>(context.GetItems(true));
Assert.Count(1, items);
Holder <int> holder = (Holder <int>)accessor.GetValue(items[0]);
Assert.AreEqual(42, holder.Value, "Should have set the value via the constructor parameter.");
}
}
public void CanBindResolvesScopedBindings()
{
JoinedDataSet dataSet = new JoinedDataSet();
DataSource dataSet1 = new DataSource("");
dataSet1.AddIndexAlias("path", 1);
dataSet1.AddDataSet(new ItemSequenceDataSet(EmptyArray <IDataItem> .Instance, 3));
IDataSet dataSet2 = new ItemSequenceDataSet(EmptyArray <IDataItem> .Instance, 2);
dataSet.AddDataSet(dataSet1);
dataSet.AddDataSet(dataSet2);
Assert.IsFalse(dataSet.CanBind(dataSet.TranslateBinding(dataSet1, new DataBinding(null, null))),
"Cannot bind because there is no path or index in the translated binding.");
Assert.IsFalse(dataSet.CanBind(dataSet.TranslateBinding(dataSet1, new DataBinding(3, null))),
"Cannot bind because index 3 is beyond the range of columns in the scoped data set.");
Assert.IsFalse(dataSet.CanBind(dataSet.TranslateBinding(dataSet2, new DataBinding(2, null))),
"Cannot bind because index 2 is beyond the range of columns in the scoped data set.");
Assert.IsTrue(dataSet.CanBind(dataSet.TranslateBinding(dataSet2, new DataBinding(1, null))),
"Can bind because index 1 is within the range of columns in the scoped data set.");
Assert.IsTrue(dataSet.CanBind(dataSet.TranslateBinding(dataSet1, new DataBinding(null, "path"))),
"Can bind because path is supported by one of the scoped data set.");
Assert.IsFalse(dataSet.CanBind(dataSet.TranslateBinding(dataSet2, new DataBinding(null, "path"))),
"Cannot bind because path is supported by one of the scoped data set.");
}
public void CanBindAppliesIndexAliasTranslation()
{
IDataSet dataSet = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSet.ColumnCount).Return(2);
Expect.Call(dataSet.CanBind(null)).IgnoreArguments().Do((CanBindDelegate) delegate(DataBinding binding)
{
Assert.AreEqual("translatedPath", binding.Path);
Assert.AreEqual(2, binding.Index);
return(true);
});
Expect.Call(dataSet.CanBind(null)).IgnoreArguments().Do((CanBindDelegate) delegate(DataBinding binding)
{
Assert.AreEqual("untranslatedPath", binding.Path);
Assert.AreEqual(5, binding.Index);
return(false);
});
}
using (Mocks.Playback())
{
DataSource source = new DataSource("theName");
source.AddIndexAlias("translatedPath", 2);
source.AddDataSet(dataSet);
Assert.IsTrue(source.CanBind(new DataBinding(5, "translatedPath")));
Assert.IsFalse(source.CanBind(new DataBinding(5, "untranslatedPath")));
}
}
public void GetItemsAppliesIndexAliasTranslation()
{
List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();
metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
IDataSet dataSet = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSet.ColumnCount).Return(3);
Expect.Call(dataSet.GetItems(null, true)).IgnoreArguments().Do((GetItemsDelegate) delegate(ICollection <DataBinding> bindings,
bool includeDynamicItems)
{
Assert.IsTrue(includeDynamicItems);
List <IDataItem> items = new List <IDataItem>();
items.Add(new ListDataItem <object>(new object[] { "abc", "def", "ghi" }, metadataPairs, true));
List <DataBinding> bindingList = new List <DataBinding>(bindings);
Assert.AreEqual("translatedPath", bindingList[0].Path);
Assert.AreEqual(2, bindingList[0].Index);
Assert.AreEqual("untranslatedPath", bindingList[1].Path);
Assert.AreEqual(1, bindingList[1].Index);
return(items);
});
}
using (Mocks.Playback())
{
DataSource source = new DataSource("theName");
source.AddIndexAlias("translatedPath", 2);
source.AddDataSet(dataSet);
DataBinding[] bindings = new DataBinding[] {
new DataBinding(5, "translatedPath"),
new DataBinding(1, "untranslatedPath")
};
List <IDataItem> items = new List <IDataItem>(source.GetItems(bindings, true));
Assert.Count(1, items);
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(1, map);
Assert.AreEqual("Bar", map.GetValue("Foo"));
Assert.Throws <ArgumentNullException>(delegate { items[0].GetValue(null); });
Assert.AreEqual("ghi", items[0].GetValue(bindings[0]));
Assert.AreEqual("def", items[0].GetValue(bindings[1]));
// Should throw ArgumentNullException when binding list is null.
Assert.Throws <ArgumentNullException>(delegate
{
items[0].GetValue(null);
});
}
}
public void AccessorObtainsAValueFromTheRow()
{
DataBinding binding = new DataBinding(0, null);
ScalarDataBinder binder = new ScalarDataBinder(binding, "name");
IDataSourceResolver resolver = Mocks.StrictMock <IDataSourceResolver>();
DataBindingContext context = new DataBindingContext(new NullConverter());
DataSource source = new DataSource("name");
source.AddDataSet(new ItemSequenceDataSet(new IDataItem[]
{
new ScalarDataItem <int>(42, null, false),
new ScalarDataItem <string>("42", null, false)
}, 1));
using (Mocks.Record())
{
Expect.Call(resolver.ResolveDataSource("name")).Return(source);
}
using (Mocks.Playback())
{
IDataAccessor accessor = binder.Register(context, resolver);
Assert.IsTrue(context.DataSets.Contains(source), "The data sets list should contain the source that was resolved during binder registration.");
List <IDataItem> items = new List <IDataItem>(context.GetItems(true));
Assert.Count(2, items);
Assert.AreEqual(42, accessor.GetValue(items[0]));
Assert.AreEqual("42", accessor.GetValue(items[1]));
}
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var invoker = new FixtureMemberInvoker <IEnumerable>(type, scope, memberName);
var dataSet = new FactoryDataSet(() => invoker.Invoke(), kind, columnCount);
dataSource.AddDataSet(dataSet);
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var invoker = new FixtureMemberInvoker<IEnumerable>(factoryType, scope, factoryMethodName);
XDocument xdocument = OpenXDocument(codeElement);
var parameters = new object[] { GetElementList(xdocument, xPath) };
var dataSet = new FactoryDataSet(() => invoker.Invoke(parameters), kind, columnCount);
dataSource.AddDataSet(dataSet);
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var dataSet = new XmlDataSet(delegate { return(OpenXPathDocument(codeElement)); }, itemPath, IsDynamic);
dataSet.DataLocationName = GetDataLocationName();
dataSource.AddDataSet(dataSet);
}
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
for (int i = 1; i <= count; i++)
{
var row = new object[] { i, "Hello from #" + i };
dataSource.AddDataSet(new ItemSequenceDataSet(new IDataItem[] { new ListDataItem <object>(row, GetMetadata(), false) }, row.Length));
}
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
using (var textReader = OpenTextReader(codeElement))
{
var text = textReader.ReadToEnd();
var dataSet = new ValueSequenceDataSet(new[] { text }, null, false);
dataSource.AddDataSet(dataSet);
}
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var invoker = new FixtureMemberInvoker <IEnumerable>(factoryType, scope, factoryMethodName);
XDocument xdocument = OpenXDocument(codeElement);
var parameters = new object[] { GetElementList(xdocument, xPath) };
var dataSet = new FactoryDataSet(() => invoker.Invoke(parameters), kind, columnCount);
dataSource.AddDataSet(dataSet);
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var dataSet = new CsvDataSet(() => OpenTextReader(codeElement), IsDynamic);
dataSet.DataLocationName = GetDataLocationName();
dataSet.FieldDelimiter = FieldDelimiter;
dataSet.CommentPrefix = CommentPrefix;
dataSet.HasHeader = HasHeader;
dataSource.AddDataSet(dataSet);
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
using (var stream = OpenStream(codeElement))
{
var bytes = new byte[stream.Length];
stream.Read(bytes, 0, bytes.Length);
var dataSet = new ValueSequenceDataSet(new[] { bytes }, null, false);
dataSource.AddDataSet(dataSet);
}
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var invoker = new FixtureMemberInvoker <IEnumerable>(factoryType, scope, factoryMethodName);
// Get List-of-Lists of Eleemnts
var listOfListsOfElements = BuildListOfNodeLists(codeElement);
// Use Gallio's invoker object to execute factory method
var parameters = new object[] { listOfListsOfElements };
var dataSet = new FactoryDataSet(() => invoker.Invoke(parameters), kind, columnCount);
dataSource.AddDataSet(dataSet);
}
public void CanGetDescriptiveDataBindingsFromItem()
{
DataSource dataSet = new DataSource("Source");
dataSet.AddDataSet(new ItemSequenceDataSet(new[] { new DataRow("abc", "def") }, 2));
dataSet.AddIndexAlias("xxx", 1);
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(EmptyArray <DataBinding> .Instance, true));
Assert.AreElementsEqual(new[]
{
new DataBinding(0, null),
new DataBinding(1, "xxx")
}, items[0].GetBindingsForInformalDescription());
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
// Create the invoker object which Gallio will call by reflection
var invoker = new FixtureMemberInvoker <IEnumerable>(factoryType, scope, factoryMethodName);
// Get an ADO DataTable from the implementation.
DataTable dataTable = BuildDataTable();
// Create the array of arguments which will be passed to the method called by the invoker
var parameters = new object[] { dataTable,
this.RowIndexIncludeFilterArray, this.RowIndexExcludeFilterArray,
this.CellValueIncludeFilterArray, this.CellValueExcludeFilterArray };
// Create a FactoryDataSet with an invoker of our factory methods in the delegate
var dataSet = new FactoryDataSet(() => invoker.Invoke(parameters), FactoryKind.Auto, 0);
dataSource.AddDataSet(dataSet);
}
public void CanBindResolvesExternalBindings()
{
JoinedDataSet dataSet = new JoinedDataSet();
DataSource dataSet1 = new DataSource("");
dataSet1.AddIndexAlias("path", 1);
dataSet1.AddDataSet(new ItemSequenceDataSet(EmptyArray <IDataItem> .Instance, 3));
IDataSet dataSet2 = new ItemSequenceDataSet(EmptyArray <IDataItem> .Instance, 2);
dataSet.AddDataSet(dataSet1);
dataSet.AddDataSet(dataSet2);
Assert.IsFalse(dataSet.CanBind(new DataBinding(null, null)),
"Cannot bind because there is no path or index.");
Assert.IsFalse(dataSet.CanBind(new DataBinding(5, null)),
"Cannot bind because index 5 is beyond the range of columns in the joined data set.");
Assert.IsTrue(dataSet.CanBind(new DataBinding(4, null)),
"Can bind because index 4 is within the range of columns in the joined data set.");
Assert.IsTrue(dataSet.CanBind(new DataBinding(0, null)),
"Can bind because index 0 is within the range of columns in the joined data set.");
Assert.IsTrue(dataSet.CanBind(new DataBinding(null, "path")),
"Can bind because path is supported by one of the data sets.");
}
public void GetItemsDelegatesToTheStrategy()
{
JoinedDataSet dataSet = new JoinedDataSet();
IList <KeyValuePair <string, string> > metadata1 = new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("abc", "123"),
new KeyValuePair <string, string>("def", "456")
};
IList <KeyValuePair <string, string> > metadata2 = new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("ghi", "789"),
};
DataSource dataSet1 = new DataSource("");
dataSet1.AddIndexAlias("path", 1);
dataSet1.AddDataSet(new ItemSequenceDataSet(new IDataItem[]
{
new ListDataItem <int>(new int[] { 1, 2, 3 }, metadata1, false),
new ListDataItem <int>(new int[] { -1, -2, -3 }, metadata2, false)
}, 3));
dataSet.AddDataSet(dataSet1);
IDataSet dataSet2 = new ItemSequenceDataSet(new IDataItem[]
{
new ListDataItem <int>(new int[] { 4, 5 }, metadata2, false),
new ListDataItem <int>(new int[] { -4, -5 }, null, true)
}, 2);
dataSet.AddDataSet(dataSet2);
List <IDataItem> dataSet1Items = new List <IDataItem>(dataSet1.GetItems(EmptyArray <DataBinding> .Instance, true));
List <IDataItem> dataSet2Items = new List <IDataItem>(dataSet2.GetItems(EmptyArray <DataBinding> .Instance, true));
List <IList <IDataItem> > results = new List <IList <IDataItem> >();
results.Add(new IDataItem[] { dataSet1Items[0], dataSet2Items[0] });
results.Add(new IDataItem[] { dataSet1Items[1], dataSet2Items[1] });
IJoinStrategy strategy = Mocks.StrictMock <IJoinStrategy>();
dataSet.Strategy = strategy;
DataBinding pathBinding = new DataBinding(null, "path");
DataBinding indexZeroBinding = new DataBinding(0, null);
DataBinding indexOneBinding = new DataBinding(1, null);
DataBinding indexThreeBinding = new DataBinding(3, null);
DataBinding[] bindings = new DataBinding[]
{
new DataBinding(null, null), // unresolvable binding because no data sets can claim it
pathBinding, // claimed by dataSet1
indexZeroBinding, // claimed by dataSet1
indexThreeBinding, // claimed by dataSet2
dataSet.TranslateBinding(dataSet1, pathBinding), // scoped by dataSet1
dataSet.TranslateBinding(dataSet2, indexOneBinding), // scoped by dataSet2
};
using (Mocks.Record())
{
Expect.Call(strategy.Join(null, null, true)).IgnoreArguments().Do((JoinDelegate) delegate(IList <IDataProvider> joinProviders, IList <ICollection <DataBinding> > joinBindingsPerProvider,
bool includeDynamicItems)
{
Assert.IsTrue(includeDynamicItems);
Assert.AreElementsEqual(new IDataProvider[] { dataSet1, dataSet2 }, joinProviders);
Assert.Count(2, joinBindingsPerProvider);
Assert.AreElementsEqual(new DataBinding[] { pathBinding, indexZeroBinding, pathBinding }, joinBindingsPerProvider[0]);
Assert.AreElementsEqual(new DataBinding[] { indexZeroBinding, indexOneBinding }, joinBindingsPerProvider[1]);
return(results);
});
}
using (Mocks.Playback())
{
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(bindings, true));
Assert.Count(2, items);
Assert.Throws <ArgumentNullException>(delegate { items[0].GetValue(null); });
Assert.Throws <DataBindingException>(delegate { items[0].GetValue(bindings[0]); });
Assert.AreEqual(2, items[0].GetValue(bindings[1]));
Assert.AreEqual(1, items[0].GetValue(bindings[2]));
Assert.AreEqual(4, items[0].GetValue(bindings[3]));
Assert.AreEqual(2, items[0].GetValue(bindings[4]));
Assert.AreEqual(5, items[0].GetValue(bindings[5]));
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(3, map);
Assert.AreEqual("123", map.GetValue("abc"));
Assert.AreEqual("456", map.GetValue("def"));
Assert.AreEqual("789", map.GetValue("ghi"));
Assert.IsFalse(items[0].IsDynamic);
Assert.Throws <DataBindingException>(delegate { items[1].GetValue(bindings[0]); });
Assert.AreEqual(-2, items[1].GetValue(bindings[1]));
Assert.AreEqual(-1, items[1].GetValue(bindings[2]));
Assert.AreEqual(-4, items[1].GetValue(bindings[3]));
Assert.AreEqual(-2, items[1].GetValue(bindings[4]));
Assert.AreEqual(-5, items[1].GetValue(bindings[5]));
map = DataItemUtils.GetMetadata(items[1]);
Assert.Count(1, map);
Assert.AreEqual("789", map.GetValue("ghi"));
Assert.IsTrue(items[1].IsDynamic);
}
}
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
dataSource.AddDataSet(new ValueSequenceDataSet(Series.U4, GetMetadata(), false));
}
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, Gallio.Common.Reflection.ICodeElementInfo codeElement)
{
dataSource.AddDataSet(new SharedDataSet());
base.PopulateDataSource(scope, dataSource, codeElement);
}
private static void EnlistImpersonationData(ITestParameterBuilder parameterBuilder, ImpersonationData data)
{
DataSource dataSource = parameterBuilder.TestDataContextBuilder.DefineDataSource("");
dataSource.AddDataSet(new ValueSequenceDataSet(new[] { data }, null, false));
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var invoker = new FixtureMemberInvoker<IEnumerable>(factoryType, scope, factoryMethodName);
// Get List-of-Lists of Eleemnts
var listOfListsOfElements = BuildListOfNodeLists(codeElement);
// Use Gallio's invoker object to execute factory method
var parameters = new object[] { listOfListsOfElements };
var dataSet = new FactoryDataSet(() => invoker.Invoke(parameters), kind, columnCount);
dataSource.AddDataSet(dataSet);
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
dataSource.AddDataSet(new ItemSequenceDataSet(new IDataItem[] { new ListDataItem <object>(values, GetMetadata(), false) }, values.Length));
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
// Create the invoker object which Gallio will call by reflection
var invoker = new FixtureMemberInvoker<IEnumerable>(factoryType, scope, factoryMethodName);
// Get an ADO DataTable from the implementation.
DataTable dataTable = BuildDataTable();
// Create the array of arguments which will be passed to the method called by the invoker
var parameters = new object[] {dataTable,
this.RowIndexIncludeFilterArray, this.RowIndexExcludeFilterArray,
this.CellValueIncludeFilterArray, this.CellValueExcludeFilterArray};
// Create a FactoryDataSet with an invoker of our factory methods in the delegate
var dataSet = new FactoryDataSet(() => invoker.Invoke(parameters), FactoryKind.Auto, 0);
dataSource.AddDataSet(dataSet);
}
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
object[] values = Enumerable.Range(1, count).Select <int, object>(i => Convert.ToChar((Convert.ToInt32('A') + i - 1)).ToString()).ToArray();
dataSource.AddDataSet(new ValueSequenceDataSet(values, GetMetadata(), false));
}
/// <inheritdoc />
protected override void PopulateDataSource(IPatternScope scope, DataSource dataSource, ICodeElementInfo codeElement)
{
var dataSet = new XmlDataSet(delegate { return OpenXPathDocument(codeElement); }, itemPath, IsDynamic);
dataSet.DataLocationName = GetDataLocationName();
dataSource.AddDataSet(dataSet);
}
