示例#1
0
        public void ProducesMetadata()
        {
            string document = "value,[Metadata]\n123,abc\n456,def";

            Gallio.Common.GallioFunc <TextReader> documentReaderProvider = delegate { return(new StringReader(document)); };
            CsvDataSet dataSet = new CsvDataSet(documentReaderProvider, false);

            dataSet.HasHeader        = true;
            dataSet.DataLocationName = "<inline>";
            Assert.AreEqual("<inline>", dataSet.DataLocationName);

            DataBinding      binding = new DataBinding(0, null);
            List <IDataItem> items   = new List <IDataItem>(dataSet.GetItems(new DataBinding[] { binding }, true));

            Assert.AreEqual("123", items[0].GetValue(binding));
            PropertyBag map = DataItemUtils.GetMetadata(items[0]);

            Assert.AreEqual("<inline>(2)", map.GetValue(MetadataKeys.DataLocation));
            Assert.AreEqual("abc", map.GetValue("Metadata"));

            Assert.AreEqual("456", items[1].GetValue(binding));
            map = new PropertyBag();
            items[1].PopulateMetadata(map);
            Assert.AreEqual("<inline>(3)", map.GetValue(MetadataKeys.DataLocation));
            Assert.AreEqual("def", map.GetValue("Metadata"));
        }
示例#2
0
        public void ProducesMetadata()
        {
            XmlDocument document = new XmlDocument();

            document.LoadXml("<root><rows><row a=\"42\" b=\"x\"><metadata xmlns=\"http://www.gallio.org/\"><entry key=\"Metadata\" value=\"abc\"/></metadata></row><row a=\"53\" b=\"y\"><metadata xmlns=\"http://www.gallio.org/\"><entry key=\"Metadata\" value=\"def\"/></metadata></row></rows></root>");

            XmlDataSet dataSet = new XmlDataSet(delegate { return(document); }, "//row", false);

            dataSet.DataLocationName = "<inline>";
            Assert.AreEqual("<inline>", dataSet.DataLocationName);

            DataBinding      binding = new DataBinding(null, "@a");
            List <IDataItem> items   = new List <IDataItem>(dataSet.GetItems(new DataBinding[] { binding }, true));

            Assert.AreEqual("42", ((XPathNavigator)items[0].GetValue(binding)).Value);
            PropertyBag map = DataItemUtils.GetMetadata(items[0]);

            Assert.AreEqual("<inline>", map.GetValue(MetadataKeys.DataLocation));
            Assert.AreEqual("abc", map.GetValue("Metadata"));

            Assert.AreEqual("53", ((XPathNavigator)items[1].GetValue(binding)).Value);
            map = DataItemUtils.GetMetadata(items[1]);
            Assert.AreEqual("<inline>", map.GetValue(MetadataKeys.DataLocation));
            Assert.AreEqual("def", map.GetValue("Metadata"));
        }
        void ChangeUserPassword()
        {
            string user = "";
            string pswd = "";

            if (deviceParams != null)
            {
                user = deviceParams.GetValue <string>("user1_name");
                pswd = deviceParams.GetValue <string>("user1_pwd");
            }

            LogonPage login = new LogonPage()
            {
                Title = StringResources.LogonPromptCameraAccount,
                SignOnButtonCaption = StringResources.LogonUpdateCameraButton,
                UserName            = user,
                Password            = pswd
            };

            if (DataStore.Instance.Cameras.Count > 1)
            {
                login.CheckboxVisibility = Windows.UI.Xaml.Visibility.Visible;
                login.CheckBoxAllCaption = StringResources.LogonUpdateCameraCheckbox;
            }

            login.Flyout(new Action(async() =>
            {
                if (!login.Cancelled && user != login.UserName || pswd != login.Password)
                {
                    await ChangeUserNamePassword(login.UserName, login.Password, login.CheckBoxAllIsChecked);
                }
            }));
        }
示例#4
0
        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);
                });
            }
        }
示例#5
0
        public void SerializationDoubleRoundtrip()
        {
            var bag = new PropertyBag();
            var t   = new SerializableObject {
                SomeValue = "test1"
            };

            bag.SetValue("foo", t);

            var w   = new StringWriter();
            var ser = new XmlDataSerializer(new DataContext());

            ser.Serialize(w, bag);
            var data = w.ToString();

            SerializableObject.CreationCount = 0;

            bag = ser.Deserialize <PropertyBag> (new StringReader(data));

            // SerializableObject is not instantiated if not queried
            Assert.AreEqual(0, SerializableObject.CreationCount);

            w = new StringWriter();
            ser.Serialize(w, bag);
            data = w.ToString();

            bag = ser.Deserialize <PropertyBag> (new StringReader(data));

            // SerializableObject is not instantiated if not queried
            Assert.AreEqual(0, SerializableObject.CreationCount);

            t = bag.GetValue <SerializableObject> ("foo");
            Assert.NotNull(t);
            Assert.AreEqual("test1", t.SomeValue);
        }
示例#6
0
        private bool GetValue(string name, bool defaultValue)
        {
            object value = PropertyBag.GetValue(name);

            if (value != null)
            {
                if (value is bool)
                {
                    return((bool)value);
                }
                string s = value as string;
                if (s != null)
                {
                    if (string.Equals(s, "true", StringComparison.OrdinalIgnoreCase))
                    {
                        return(true);
                    }
                    if (string.Equals(s, "false", StringComparison.OrdinalIgnoreCase))
                    {
                        return(false);
                    }
                }
            }
            return(defaultValue);
        }
示例#7
0
        public void GetMetadataReturnsSameEnumerationAsWasSpecifiedInConstructor()
        {
            List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();

            metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
            BaseDataItem item = new StubDataItem(metadataPairs, false);

            PropertyBag map = DataItemUtils.GetMetadata(item);

            Assert.Count(1, map);
            Assert.AreEqual("Bar", map.GetValue("Foo"));
        }
示例#8
0
        public void ContainSameMetadataAsSpecifiedInConstructor()
        {
            List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();

            metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
            ScalarDataItem <object> item = new ScalarDataItem <object>("abc", metadataPairs, false);

            PropertyBag map = DataItemUtils.GetMetadata(item);

            Assert.Count(1, map);
            Assert.AreEqual("Bar", map.GetValue("Foo"));
        }
示例#9
0
        public void ShouldProvideFluentInterfaceForBuildingMetadata()
        {
            PropertyBag extraMetadata = new PropertyBag();

            extraMetadata.SetValue("Author", "Lewis Carroll");
            extraMetadata.SetValue("Title", "The Jabberwocky");

            DataRow row = new DataRow("abc")
                          .WithMetadata("Description", "Frumious")
                          .WithMetadata("Name", "Bandersnatch")
                          .WithMetadata(extraMetadata);

            Assert.AreEqual("abc", row.GetValue(new DataBinding(0, null)));

            PropertyBag map = DataItemUtils.GetMetadata(row);

            Assert.Count(4, map);
            Assert.AreEqual("Frumious", map.GetValue("Description"));
            Assert.AreEqual("Bandersnatch", map.GetValue("Name"));
            Assert.AreEqual("Lewis Carroll", map.GetValue("Author"));
            Assert.AreEqual("The Jabberwocky", map.GetValue("Title"));
        }
示例#10
0
        public static void SetDefaultSerializer(Solution sln)
        {
            PropertyBag userProperties = sln.UserProperties;
            string      baseDirectory  = (string)sln.BaseDirectory;

            if (!string.IsNullOrEmpty(userProperties.GetValue <string>("DefaultSerializer", string.Empty)))
            {
                return;
            }
            string defaultSerializerId = VersionHelper.GetDefaultSerializerID(sln);

            userProperties.SetValue <string>("DefaultSerializer", defaultSerializerId);
            sln.SaveUserProperties();
        }
示例#11
0
        public void GetAndSetValue()
        {
            PropertyBag bag = new PropertyBag();

            Assert.IsNull(bag.GetValue("key"));

            bag.SetValue("key", "value");
            Assert.AreEqual("value", bag.GetValue("key"));

            bag.SetValue("key", "different value");
            Assert.AreEqual("different value", bag.GetValue("key"));

            bag.SetValue("key", null);
            Assert.IsNull(bag.GetValue("key"));

            bag.Add("key", "value1");
            bag.Add("key", "value2");
            Assert.AreEqual("value1", bag.GetValue("key"));
            Assert.AreElementsEqual(new[] { "value1", "value2" }, bag["key"]);

            bag.SetValue("key", "value");
            Assert.AreElementsEqual(new[] { "value" }, bag["key"]);
        }
示例#12
0
        public void ItemsContainSameMetadataAsSpecifiedInConstructor()
        {
            List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();

            metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));

            ValueSequenceDataSet dataSet = new ValueSequenceDataSet(new object[] { "a" }, metadataPairs, false);
            List <IDataItem>     items   = new List <IDataItem>(dataSet.GetItems(EmptyArray <DataBinding> .Instance, true));

            PropertyBag map = DataItemUtils.GetMetadata(items[0]);

            Assert.Count(1, map);
            Assert.AreEqual("Bar", map.GetValue("Foo"));
        }
示例#13
0
        void LoadItemProperties(PropertyBag props, SolutionItem item, string path)
        {
            PropertyBag info = props.GetValue <PropertyBag> (path);

            if (info != null)
            {
                item.LoadUserProperties(info);
                props.RemoveValue(path);
            }

            SolutionFolder sf = item as SolutionFolder;

            if (sf != null)
            {
                foreach (SolutionItem ci in sf.Items)
                {
                    LoadItemProperties(props, ci, path + "." + ci.Name);
                }
            }
        }
		public void SerializationRoundtrip ()
		{
			var bag = new PropertyBag ();
			var t = new SerializableObject {
				SomeValue = "test1"
			};
			bag.SetValue ("foo", t);

			var w = new StringWriter ();
			var ser = new XmlDataSerializer (new DataContext ());
			ser.Serialize (w, bag);

			SerializableObject.CreationCount = 0;

			var data = w.ToString ();
			bag = ser.Deserialize<PropertyBag> (new StringReader (data));

			// SerializableObject is not instantiated if not queried
			Assert.AreEqual (0, SerializableObject.CreationCount);

			t = bag.GetValue<SerializableObject> ("foo");
			Assert.NotNull (t);
			Assert.AreEqual ("test1", t.SomeValue);
		}
示例#15
0
        public void GetAndSetValue()
        {
            PropertyBag bag = new PropertyBag();

            Assert.IsNull(bag.GetValue("key"));

            bag.SetValue("key", "value");
            Assert.AreEqual("value", bag.GetValue("key"));

            bag.SetValue("key", "different value");
            Assert.AreEqual("different value", bag.GetValue("key"));

            bag.SetValue("key", null);
            Assert.IsNull(bag.GetValue("key"));

            bag.Add("key", "value1");
            bag.Add("key", "value2");
            Assert.AreEqual("value1", bag.GetValue("key"));
            Assert.AreElementsEqual(new[] { "value1", "value2" }, bag["key"]);

            bag.SetValue("key", "value");
            Assert.AreElementsEqual(new[] { "value" }, bag["key"]);
        }
示例#16
0
        public void ProducesMetadata()
        {
            string document = "value,[Metadata]\n123,abc\n456,def";
            Func<TextReader> documentReaderProvider = delegate { return new StringReader(document); };
            CsvDataSet dataSet = new CsvDataSet(documentReaderProvider, false);

            dataSet.HasHeader = true;
            dataSet.DataLocationName = "<inline>";
            Assert.AreEqual("<inline>", dataSet.DataLocationName);

            DataBinding binding = new DataBinding(0, null);
            List<IDataItem> items = new List<IDataItem>(dataSet.GetItems(new DataBinding[] { binding }, true));

            Assert.AreEqual("123", items[0].GetValue(binding));
            PropertyBag map = DataItemUtils.GetMetadata(items[0]);
            Assert.AreEqual("<inline>(2)", map.GetValue(MetadataKeys.DataLocation));
            Assert.AreEqual("abc", map.GetValue("Metadata"));

            Assert.AreEqual("456", items[1].GetValue(binding));
            map = new PropertyBag();
            items[1].PopulateMetadata(map);
            Assert.AreEqual("<inline>(3)", map.GetValue(MetadataKeys.DataLocation));
            Assert.AreEqual("def", map.GetValue("Metadata"));
        }
        private void ShowParameters(PropertyBag props)
        {
            if (props.GetValue <string>("Error") != null)
            {
                return;
            }

            string alias = props.GetValue <string>("alias");

            if (alias != device.CameraInfo.Name)
            {
                device.CameraInfo.Name = alias;
            }

            int          wifi_enable    = props.GetValue <int>("wifi_enable");
            string       wifi_ssid      = props.GetValue <string>("wifi_ssid");
            WifiSecurity wifi_encrypt   = (WifiSecurity)props.GetValue <int>("wifi_encrypt");
            int          wifi_authtype  = props.GetValue <int>("wifi_authtype");
            int          wifi_keyformat = props.GetValue <int>("wifi_keyformat");

            // ignore all this WEP crap, hopefully user doesn't have
            string wifi_defkey = props.GetValue <string>("wifi_defkey");
            string wifi_key1   = props.GetValue <string>("wifi_key1");
            string wifi_key2   = props.GetValue <string>("wifi_key2");
            string wifi_key3   = props.GetValue <string>("wifi_key3");
            string wifi_key4   = props.GetValue <string>("wifi_key4");

            string wifi_key1_bits = props.GetValue <string>("wifi_key1_bits");
            string wifi_key2_bits = props.GetValue <string>("wifi_key2_bits");
            string wifi_key3_bits = props.GetValue <string>("wifi_key3_bits");
            string wifi_key4_bits = props.GetValue <string>("wifi_key4_bits");

            // this is where mode 4 key shows up
            string wifi_wpa_psk = props.GetValue <string>("wifi_wpa_psk");

            switch (wifi_encrypt)
            {
            case WifiSecurity.None:
                break;

            case WifiSecurity.WepTkip:
                break;

            case WifiSecurity.WpaAes:
                break;

            case WifiSecurity.Wpa2Aes:
                break;

            case WifiSecurity.Wpa2Tkip:
                device.CameraInfo.WifiPassword = wifi_wpa_psk;
                break;

            default:
                break;
            }

            if (!string.IsNullOrEmpty(wifi_ssid))
            {
                var network = new WifiNetworkInfo()
                {
                    SSID     = wifi_ssid,
                    Mode     = WifiMode.Infrastructure,
                    Security = wifi_encrypt
                };

                device.CameraInfo.WifiNetwork = network;
            }
        }
示例#18
0
 public TProperty GetValue <TProperty>(
     [CallerMemberName] string propertyName = "")
 {
     return(_propertyBag.GetValue <TProperty>(
                propertyName));
 }
示例#19
0
 private static string GetDefaultSerializerID(Solution sln)
 {
     try
     {
         PropertyBag userProperties = sln.UserProperties;
         string      empty          = string.Empty;
         if (!userProperties.GetValue <bool>("publishHasCocos2dxCode", true))
         {
             return("Serializer_FlatBuffers");
         }
         if (userProperties.HasValue("publishCocos2dxMainVersion"))
         {
             if (userProperties.GetValue <int>("publishCocos2dxMainVersion") == 2)
             {
                 return("Serializer_Json");
             }
         }
         else
         {
             string versionFileV2 = VersionHelper.TryGetVersionFileV2(sln);
             if (!string.IsNullOrEmpty(versionFileV2))
             {
                 userProperties.SetValue <string>("publishCocos2dxVersionText", versionFileV2);
                 userProperties.SetValue <int>("publishCocos2dxMainVersion", 2);
                 return("Serializer_Json");
             }
         }
         if (userProperties.HasValue("publishCocos2dxCodeLanguage"))
         {
             if (userProperties.GetValue <EnumProjectLanguage>("publishCocos2dxCodeLanguage") == EnumProjectLanguage.js)
             {
                 return("Serializer_Json");
             }
         }
         else
         {
             string versionFileV3Js = VersionHelper.TryGetVersionFileV3_js(sln);
             if (!string.IsNullOrEmpty(versionFileV3Js))
             {
                 userProperties.SetValue <string>("publishCocos2dxVersionText", versionFileV3Js);
                 userProperties.SetValue <int>("publishCocos2dxMainVersion", 3);
                 userProperties.SetValue <EnumProjectLanguage>("publishCocos2dxCodeLanguage", EnumProjectLanguage.js);
                 return("Serializer_Json");
             }
         }
         string versionText1 = userProperties.GetValue <string>("publishCocos2dxVersionText", string.Empty);
         if (!string.IsNullOrEmpty(versionText1))
         {
             return(VersionHelper.IsSupportBinary(versionText1) ? "Serializer_FlatBuffers" : "Serializer_Json");
         }
         string versionText2 = VersionHelper.TryGetVersionFileV3_cpp(sln);
         if (string.IsNullOrEmpty(versionText2))
         {
             versionText2 = VersionHelper.TryGetVersionFileV3_lua(sln);
         }
         if (!string.IsNullOrEmpty(versionText2))
         {
             return(VersionHelper.IsSupportBinary(versionText2) ? "Serializer_FlatBuffers" : "Serializer_Json");
         }
         string versionFileDefaultLua = VersionHelper.TryGetVersionFileDefault_lua(sln);
         if (string.IsNullOrEmpty(versionFileDefaultLua))
         {
             return("Serializer_FlatBuffers");
         }
         userProperties.SetValue <string>("publishCocos2dxVersionText", versionFileDefaultLua);
         return("Serializer_FlatBuffers");
     }
     catch (Exception ex)
     {
         LogConfig.Logger.Error((object)("获取默认发布器时出错:\r\n" + ex.ToString()));
         return("Serializer_FlatBuffers");
     }
 }
示例#20
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);
            }
        }