Exemple #1
0
        public void RegisteredBindingsAreFetchedByItemsAccordingToStrategy()
        {
            ItemSequenceDataSet dataSet1 = new ItemSequenceDataSet(new IDataItem[] { new ScalarDataItem <int>(1, null, false), new ScalarDataItem <int>(2, null, false) }, 1);
            ItemSequenceDataSet dataSet2 = new ItemSequenceDataSet(new IDataItem[] { new ScalarDataItem <int>(10, null, false), new ScalarDataItem <int>(20, null, false) }, 1);

            DataBindingContext context = new DataBindingContext(new NullConverter());

            IDataAccessor accessor1 = context.RegisterBinding(dataSet1, new DataBinding(0, null));
            IDataAccessor accessor2 = context.RegisterBinding(dataSet2, new DataBinding(0, null));

            List <IDataItem> combinatorialItems = new List <IDataItem>(context.GetItems(true));

            Assert.Count(4, combinatorialItems);
            Assert.AreEqual(1, accessor1.GetValue(combinatorialItems[0]));
            Assert.AreEqual(10, accessor2.GetValue(combinatorialItems[0]));
            Assert.AreEqual(1, accessor1.GetValue(combinatorialItems[1]));
            Assert.AreEqual(20, accessor2.GetValue(combinatorialItems[1]));
            Assert.AreEqual(2, accessor1.GetValue(combinatorialItems[2]));
            Assert.AreEqual(10, accessor2.GetValue(combinatorialItems[2]));
            Assert.AreEqual(2, accessor1.GetValue(combinatorialItems[3]));
            Assert.AreEqual(20, accessor2.GetValue(combinatorialItems[3]));

            context.Strategy = SequentialJoinStrategy.Instance;

            List <IDataItem> sequentialItems = new List <IDataItem>(context.GetItems(true));

            Assert.Count(2, sequentialItems);
            Assert.AreEqual(1, accessor1.GetValue(sequentialItems[0]));
            Assert.AreEqual(10, accessor2.GetValue(sequentialItems[0]));
            Assert.AreEqual(2, accessor1.GetValue(sequentialItems[1]));
            Assert.AreEqual(20, accessor2.GetValue(sequentialItems[1]));
        }
Exemple #2
0
        public void RowEnumerationIsSameAsSpecifiedInConstructorWhenIncludingDynamicRows()
        {
            List <IDataItem>    items   = new List <IDataItem>();
            ItemSequenceDataSet dataSet = new ItemSequenceDataSet(items, 5);

            Assert.AreSame(items, dataSet.GetItems(EmptyArray <DataBinding> .Instance, true));
        }
Exemple #3
0
        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.");
        }
Exemple #4
0
        public void DataBindingAccessorThrowsIfItemIsNull()
        {
            ItemSequenceDataSet dataSet = new ItemSequenceDataSet(new IDataItem[] { }, 1);
            DataBindingContext  context = new DataBindingContext(Mocks.Stub <IConverter>());

            IDataAccessor accessor = context.RegisterBinding(dataSet, new DataBinding(0, null));

            Assert.Throws <ArgumentNullException>(delegate { accessor.GetValue(null); });
        }
Exemple #5
0
        public void RowEnumerationIsFilteredWhenNotIncludingDynamicRows()
        {
            List <IDataItem> items = new List <IDataItem>();

            items.Add(new ScalarDataItem <int>(42, null, true));
            items.Add(new ScalarDataItem <int>(53, null, false));

            ItemSequenceDataSet dataSet = new ItemSequenceDataSet(items, 5);

            List <IDataItem> result = new List <IDataItem>(dataSet.GetItems(EmptyArray <DataBinding> .Instance, false));

            Assert.Count(1, result);
            Assert.AreSame(items[1], result[0]);
        }
Exemple #6
0
        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.");
        }
Exemple #7
0
        public void CanBindReturnsTrueOnlyIfTheBindingIndexIsBetweenZeroAndColumnCount(bool expectedResult, string path, object index)
        {
            ItemSequenceDataSet dataSet = new ItemSequenceDataSet(EmptyArray <IDataItem> .Instance, 3);

            Assert.AreEqual(expectedResult, dataSet.CanBind(new DataBinding((int?)index, path)));
        }
Exemple #8
0
        public void ColumnCountIsSameAsSpecifiedInConstructor()
        {
            ItemSequenceDataSet dataSet = new ItemSequenceDataSet(EmptyArray <IDataItem> .Instance, 5);

            Assert.AreEqual(5, dataSet.ColumnCount);
        }
Exemple #9
0
        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);
            }
        }