public static void AddAttributes(string @event, AttributeCollection attributes) { HttpBrowserCapabilities client = HttpContext.Current.Request.Browser; BrowserType browserType = _userAgentParser.Parse(client); switch (browserType) { case BrowserType.IE5Up: case BrowserType.IE6Up: case BrowserType.IE7Up: attributes.Add(@event, IEHomepageAction); break; case BrowserType.FireFox2: case BrowserType.Mozilla: case BrowserType.WebKit: attributes.Add(@event, MozHomepageAction); break; case BrowserType.Netscape: attributes.Add(@event, NSHomepageAction); break; default: attributes.Add(@event, DefaultHomepageAction); break; } return; }
public void TestGetFromGlobalCollection() { float experienceValue = 10.0f; float levelValue = 3.0f; // Create test incoming attribute dictionary var incomingAttributeDictionary = new Dictionary <AttributeEnums.AttributeType, float> () { { _experienceType, experienceValue }, { _levelType, levelValue } }; // Create "Global" dictionary _collection = new AttributeCollection(); _collection.Add(_a1); _collection.Add(_a2); // Create new local collection AttributeCollection localCollection = new AttributeCollection(); // Populate local collection with values from global one localCollection = AttributeCollection.GetFromGlobalCollection(incomingAttributeDictionary, _collection, localCollection); Attribute localExperienceAttribute = localCollection.Get(_experienceType); Attribute localLevelAttribute = localCollection.Get(_levelType); // Verify that the deep copy worked Assert.AreNotSame(localExperienceAttribute, _collection.Get(_experienceType)); Assert.AreNotSame(localLevelAttribute, _collection.Get(_levelType)); // Verify the current values Assert.AreEqual(experienceValue, localExperienceAttribute.CurrentValue); Assert.AreEqual(levelValue, localLevelAttribute.CurrentValue); }
public void TestAddingExistingAttribute() { bool exceptionThrown; AttributeCollection attributes = new AttributeCollection(); AttributeValue newAttributeValue = new AttributeValue("Test Value"); // Add attribute and attribute value attributes.Add("Test", newAttributeValue); Assert.AreEqual <string>(newAttributeValue.Value, attributes["Test"].Value); AttributeValue existingAttributeValue = new AttributeValue("Test Value"); try { attributes.Add("Test", existingAttributeValue); exceptionThrown = false; } catch (ArgumentException) { exceptionThrown = true; } Assert.IsTrue(exceptionThrown); }
//-------------------------------------------------------------------------------------------------------------------------------------------------------------- /// <summary> /// 22-Mar-2016 - DEPRECATED - Checked and no longer used ... /// </summary> public static void AddMouseOverEvents(AttributeCollection atts, string imageID, string srcImgPath, string imageFileName) { // check for tildas and default if found them if (srcImgPath != null && srcImgPath.Contains("~")) { srcImgPath = ImageRootDirectory; } // see if there is an attribute there already - if so, then append it if (atts["onmouseout"] != null && atts["onmouseout"] != "") { atts["onmouseout"] = atts["onmouseout"] + "document.getElementById('" + imageID + "').src='" + srcImgPath + imageFileName + "';"; } else { atts.Add("onmouseout", "javascript:document.getElementById('" + imageID + "').src='" + srcImgPath + imageFileName + "';"); } if (atts["onmouseover"] != null && atts["onmouseover"] != "") { atts["onmouseover"] = atts["onmouseover"] + "document.getElementById('" + imageID + "').src='" + srcImgPath + HTMLUtilities.GetHoverImageName(imageFileName) + "';"; } else { atts.Add("onmouseover", "javascript:document.getElementById('" + imageID + "').src='" + srcImgPath + HTMLUtilities.GetHoverImageName(imageFileName) + "';"); } }
public void TestAddingExistingAttribute() { bool exceptionThrown; AttributeCollection attributes = new AttributeCollection(); AttributeValue newAttributeValue = new AttributeValue("Test Value"); // Add attribute and attribute value attributes.Add("Test", newAttributeValue); Assert.AreEqual<string>(newAttributeValue.Value, attributes["Test"].Value); AttributeValue existingAttributeValue = new AttributeValue("Test Value"); try { attributes.Add("Test", existingAttributeValue); exceptionThrown = false; } catch (ArgumentException) { exceptionThrown = true; } Assert.IsTrue(exceptionThrown); }
public void TestDeepCopy() { _collection = new AttributeCollection(); _collection.Add(_a1.Type, _a1); _collection.Add(_a2); // Make sure shallow copies are the same AttributeCollection shallowCopy = _collection; Assert.AreSame(_collection, shallowCopy); foreach (var attribute in _collection.GetAttributes()) { Assert.AreEqual(attribute.Value.CurrentValue, shallowCopy.Get(attribute.Key).CurrentValue); } // Make sure deep copies are different AttributeCollection deepCopy = _collection.DeepCopy(); deepCopy.Get(_a1.Type).CurrentValue = 40; deepCopy.Get(_a2.Type).CurrentValue = 4; Assert.AreNotSame(_collection, deepCopy); foreach (var attribute in _collection.GetAttributes()) { Assert.AreNotEqual(attribute.Value.CurrentValue, deepCopy.Get(attribute.Key).CurrentValue); } }
/// <summary> /// Renders the beginning tag that wraps around the rendered HTML. /// This method uses the <see cref="OuterTag"/> property to determine the tag name. /// </summary> /// <returns>The beginning tag HTML code.</returns> public override string RenderBeginTag() { HtmlTextWriter writer = CreateHtmlTextWriter(); AttributeCollection attributes = new AttributeCollection(new StateBag(true)); string cssClass = Settings.RadioButtonList.CssClass; string disabledCssClass = Settings.RadioButtonList.DisabledCssClass; string repeatDirectionCssClass = Control.RepeatDirection.ToString().ToLowerInvariant(); string allClasses = ConcatenateCssClasses(cssClass, repeatDirectionCssClass, (Control.Enabled ? String.Empty : disabledCssClass), Control.CssClass); writer.WriteBeginTag(this.OuterTag); attributes.Add("id", Control.ClientID); if (!String.IsNullOrEmpty(allClasses)) { attributes.Add("class", allClasses); } AddDefautAttributesToCollection(Control, attributes); WriteAttributes(writer, attributes); writer.WriteLine(HtmlTextWriter.TagRightChar); return(writer.InnerWriter.ToString()); }
public void TestLoadData() { // Setup attributes Attribute a1 = new Attribute(AttributeEnums.AttributeType.EXPERIENCE, "EXP", "EXP", "", 50, 0, 100); Attribute a2 = new Attribute(AttributeEnums.AttributeType.LEVEL, "LVL", "LVL", "", 5, 1, 10); _ac.Add(a1); _ac.Add(a2); // Setup inventory slots Item i1 = new Item(0, Item.ItemType.WEAPON, "weapon", "weapon description", "weapon", _ac, InventorySlots.SlotType.RIGHT_HAND, Item.ItemTier.TIER_5, "weapon.jpg", "swordSFX", "swordVFX"); Item i2 = new Item(1, Item.ItemType.ARMOR, "armor", "aermor description", "armor", _ac, InventorySlots.SlotType.BODY, Item.ItemTier.TIER_3, "armor.jpg", "swordSFX", "swordVFX"); _slots.Add(i1); _slots.Add(i2); // Setup abiltiies Ability ability1 = new Ability(0, Ability.AbilityType.ATTACK, "attack", "attack_description", "attackTooltop", "attackIconPath", "attackVfxPath", 0, 0, Ability.TargetTypeEnum.DEFAULT, null); Ability ability2 = new Ability(1, Ability.AbilityType.LAST_RESORT, "lr", "lrDescription", "lrTooltop", "lrIconPath", "lrVfxPath", 0, 0, Ability.TargetTypeEnum.DEFAULT, null); _abilityCollection.Add(ability1); _abilityCollection.Add(ability2); // Setup units _u1.FirstName = "Leonard"; _u1.LastName = "Bedner"; _u1.AttributeCollection = _ac; _u1.Class = "Developer"; _u1.InventorySlots = _slots; _u1.AbilityCollection = _abilityCollection; }
/// <summary> /// Removes references fields for pass 1 and all the others for pass 2. /// </summary> /// <param name="entity">Entity to process.</param> /// <param name="passNumber">Pass Number.</param> private void ProcessReferenceFields(EntityWrapper entity, int passNumber) { // Don't process manyTomany in pass 2 if (entity.IsManyToMany && passNumber == (int)PassType.UpdateLookups) { return; } AttributeCollection newCollection = new AttributeCollection(); foreach (KeyValuePair <string, object> item in entity.OriginalEntity.Attributes) { var idAliasKey = metCache.GetIdAliasKey(entity.OriginalEntity.LogicalName); if (item.Value != null && (item.Value is EntityReference || item.Value is EntityCollection || item.Value is AliasedValue)) { // For pass 2(Update Lookups) don't filter, add all attributes if (passNumber == (int)PassType.UpdateLookups) { newCollection.Add(item); } // For pass 1 (CreateEntity) EntityReference and Alias AddEntityReferenceAndAliasAttributesToCollection(passNumber, newCollection, item, idAliasKey); } else if ((passNumber == (int)PassType.CreateRequiredEntity) || (passNumber == (int)PassType.CreateEntity) || item.Key.StartsWith(idAliasKey, StringComparison.InvariantCulture)) { newCollection.Add(item); } } entity.OriginalEntity.Attributes = newCollection; }
/// <summary> /// Renders the beginning tag that wraps around the rendered HTML. /// </summary> /// <returns>The beginning tag HTML code.</returns> public override string RenderBeginTag() { HtmlTextWriter writer = CreateHtmlTextWriter(); AttributeCollection attributes = new AttributeCollection(new StateBag(true)); string cssClass = Settings.Wizard.CssClass; string disabledCssClass = Settings.CheckBoxList.DisabledCssClass; string allClasses = ConcatenateCssClasses( cssClass, (Control.Enabled ? String.Empty : disabledCssClass), Control.CssClass); writer.WriteBeginTag("div"); attributes.Add("id", Control.ClientID); if (!String.IsNullOrEmpty(allClasses)) { attributes.Add("class", allClasses); } if (Control.TabIndex > 0) { attributes.Add("tabindex", Control.TabIndex.ToString()); } AddDefautAttributesToCollection(Control, attributes); WriteAttributes(writer, attributes); writer.WriteLine(HtmlTextWriter.TagRightChar); return(writer.InnerWriter.ToString()); }
private static AttributeCollection GetAttributes(CrmEntityBase crmEntity, PropertyHelper[] helpers) { var attributes = new AttributeCollection(); var relevantHelpers = helpers.Where(ph => ph.CRMFieldBaseAttribute != null); foreach (var helper in relevantHelpers) { var key = helper.CRMFieldBaseAttribute.AttributeName; var modelValue = helper.GetValue(crmEntity); var value = modelValue; if (helper.CRMFieldBaseAttribute.Type != CRMFieldType.Basic) { value = GetCrmValue(helper.CRMFieldBaseAttribute, modelValue); } if (!ignoreNulls) { attributes.Add(key, value); } else if (value != null) { attributes.Add(key, value); } } return(attributes); }
/// <summary> /// Prepares the entity. /// </summary> /// <returns>Entity.</returns> public override AttributeCollection PrepareEntity() { AttributeCollection ac = new AttributeCollection(); ac.Add("mwns_name", Name); ac.Add("mwns_identifier", Identifier); return(ac); }
/// <summary> /// Renders a menu item. Is used recursively to handle child menu items. /// </summary> /// <param name="writer">The <see cref="HtmlTextWriter"/> to use to generate HTML.</param> /// <param name="item">The menu item to render.</param> /// <param name="level">The level of this menu item (hierarchical level).</param> protected void RenderMenuItem(HtmlTextWriter writer, MenuItem item, int level) { bool enabled = (item.Enabled && Control.Enabled); string cssClass = (enabled ? String.Empty : Settings.Menu.DisabledCssClass); writer.Write("\t"); writer.WriteBeginTag("li"); if (!String.IsNullOrEmpty(cssClass)) { writer.WriteAttribute("class", cssClass); } writer.Write(HtmlTextWriter.TagRightChar); AttributeCollection attributes = new AttributeCollection(new StateBag(true)); writer.WriteBeginTag("a"); if (!String.IsNullOrEmpty(item.ToolTip)) { attributes.Add("title", item.ToolTip); } if (enabled && item.Selectable && Control.Page != null) { string href = this.Control.Page.ClientScript.GetPostBackClientHyperlink(Control, item.Value); attributes.Add("href", href); } WriteAttributes(writer, attributes); writer.Write(HtmlTextWriter.TagRightChar); writer.Write((String.IsNullOrEmpty(item.Text) ? item.Value : item.Text)); writer.WriteEndTag("a"); if (item.ChildItems != null && item.ChildItems.Count > 0 && level < (Control.StaticDisplayLevels + Control.MaximumDynamicDisplayLevels)) { writer.WriteBeginTag("ul"); if (level >= Control.StaticDisplayLevels) { writer.WriteAttribute("class", "dynamic"); } writer.Write(HtmlTextWriter.TagRightChar); writer.WriteLine(); writer.Indent++; foreach (MenuItem innerItem in item.ChildItems) { RenderMenuItem(writer, innerItem, level + 1); } writer.Indent--; writer.WriteEndTag("ul"); writer.WriteLine(); } writer.WriteEndTag("li"); writer.WriteLine(); }
/// <summary> /// Prepares the entity. /// </summary> /// <returns>Entity.</returns> public override AttributeCollection PrepareEntity() { AttributeCollection ac = new AttributeCollection(); ac.Add("mwns_name", Name); ac.Add("mwns_value", Value); ac.Add("mwns_securevalue", SecureValue); ac.Add("mwns_mawenssolutionid", new EntityReference("mwns_mawenssolution", SolutionId)); return(ac); }
public void Add_Duplicates_MixedCase_OneAttribute() { var attributes = new AttributeCollection(); attributes.Add("assembly", "A"); attributes.Add("ASSEMBLY", "a"); Assert.Single(attributes); Assert.Single(attributes.First().Value); }
public void TestRemovingInvalidAttribute() { AttributeCollection attributes = new AttributeCollection(); attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); Assert.IsFalse(attributes.Remove("Test5")); }
public void Setup() { Attribute range = new Attribute(AttributeEnums.AttributeType.RANGE, "range", "rng", "range", 4.0f, 1.0f, 100.0f); Attribute aoeRange = new Attribute(AttributeEnums.AttributeType.AOE_RANGE, "aoeRange", "aoerng", "aoerange", 1.0f, 1.0f, 100.0f); _attributeCollection = new AttributeCollection(); _attributeCollection.Add(range); _attributeCollection.Add(aoeRange); _ability1 = new Ability(0, Ability.AbilityType.MAGIC, "test_magic", "test_magic", "test_magic", "iconPath", "vfxPath", 1, 0, Ability.TargetTypeEnum.DEFAULT, _attributeCollection); }
public void Add_Multiple_MultipleAttributes() { const int ExpectedAttributeCount = 2; var attributes = new AttributeCollection(); attributes.Add("Assembly", "A"); attributes.Add("Parameter", "B"); Assert.Equal(ExpectedAttributeCount, attributes.Count); }
private Entity CreateCurrencyEntity(string currencyCode, Guid currencyId) { var attributes = new AttributeCollection(); attributes.Add(CurrencyAttribute.CurrencyCode, currencyCode); attributes.Add(CurrencyAttribute.ExchangeRate, 1M); return(new Entity(CurrencyAttribute.EntityName) { Id = currencyId, Attributes = attributes }); }
protected override void OnPreRender(EventArgs e) { if (!string.IsNullOrEmpty(this.ViewModel)) { if (this.ServiceUrl != null) { this["ServiceUrl"] = EcpUrl.ProcessUrl(this.ServiceUrl.ServiceUrl); } AttributeCollection bindingContextAttributes = this.GetBindingContextAttributes(); bindingContextAttributes.Add("data-type", this.ViewModel); foreach (KeyValuePair <string, object> keyValuePair in this.dataContextProperties) { object value = keyValuePair.Value; string value2; if (value is string) { value2 = (string)value; } else if (value is bool) { value2 = value.ToString().ToLower(); } else if (value is int || value is uint || value is long || value is ulong || value is float || value is double) { value2 = value.ToString(); } else { value2 = "json:" + keyValuePair.Value.ToJsonString(DDIService.KnownTypes.Value); } bindingContextAttributes.Add("vm-" + keyValuePair.Key, value2); } if (bindingContextAttributes != base.Attributes) { List <string> list = new List <string>(base.Attributes.Count); foreach (object obj in base.Attributes.Keys) { string text = obj as string; if (text != null && text.StartsWith("vm-")) { bindingContextAttributes.Add(text, base.Attributes[text]); list.Add(text); } } foreach (string key in list) { base.Attributes.Remove(key); } } } base.OnPreRender(e); }
public void TestCountingCollectionItems() { AttributeCollection attributes = new AttributeCollection(); Assert.AreEqual <int>(0, attributes.Count); attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); Assert.AreEqual <int>(4, attributes.Count); }
public void Setup() { Attribute range = new Attribute(AttributeEnums.AttributeType.RANGE, "range", "rng", "range", 4.0f, 1.0f, 100.0f); Attribute aoeRange = new Attribute(AttributeEnums.AttributeType.AOE_RANGE, "aoeRange", "aoerng", "aoerange", 1.0f, 1.0f, 100.0f); _attributeCollection = new AttributeCollection(); _attributeCollection.Add(range); _attributeCollection.Add(aoeRange); _ability1 = new Ability(0, Ability.AbilityType.MAGIC, "test_magic", "test_magic", "test_magic", "iconPath", "vfxPath", 1, 0, Ability.TargetTypeEnum.DEFAULT, _attributeCollection); _ability2 = new Ability(1, Ability.AbilityType.TALENT, "testTalent", "testTalent", "testTalent", "iconPath", "vfxPath", 1, 0, Ability.TargetTypeEnum.DEFAULT, _attributeCollection); _ability3 = new Ability(2, Ability.AbilityType.ATTACK, "testAttack", "testAttack", "testAttack", "iconPath", "vfxPath", 1, 0, Ability.TargetTypeEnum.DEFAULT, _attributeCollection); _ability4 = new Ability(3, Ability.AbilityType.MAGIC, "testMagic2", "testMagic2", "testMagic2", "iconPath", "vfxPath", 1, 0, Ability.TargetTypeEnum.DEFAULT, _attributeCollection); _ability5 = new Ability(4, Ability.AbilityType.TALENT, "testTalent2", "testTalent2", "testTalent2", "iconPath", "vfxPath", 1, 0, Ability.TargetTypeEnum.DEFAULT, _attributeCollection); }
protected override void CreateChildControls() { this.Controls.Clear(); WebControl webControl = new WebControl(HtmlTextWriterTag.Input); if (!string.IsNullOrEmpty(base.CssClass)) { webControl.Attributes.Add("class", base.CssClass); } if (!string.IsNullOrEmpty(this.BoxStyle)) { webControl.Attributes.Add("style", this.BoxStyle); } webControl.Attributes.Add("id", "buyAmount"); webControl.Attributes.Add("type", "text"); AttributeCollection attributes = webControl.Attributes; int quantity = this.Quantity; attributes.Add("value", quantity.ToString(CultureInfo.InvariantCulture)); WebControl webControl2 = new WebControl(HtmlTextWriterTag.Input); webControl2.Attributes.Add("id", "oldBuyNumHidden"); webControl2.Attributes.Add("type", "hidden"); AttributeCollection attributes2 = webControl2.Attributes; quantity = this.Quantity; attributes2.Add("value", quantity.ToString(CultureInfo.InvariantCulture)); this.Controls.Add(webControl); this.Controls.Add(webControl2); }
/// <summary> /// Adds the confirm message JS. /// </summary> /// <param name="jsEvent">The js event.</param> /// <param name="attributeCollection">The attribute collection.</param> /// <param name="chekMessage">The chek message.</param> public static void AddConfirmMessageJS(string jsEvent, AttributeCollection attributeCollection, string chekMessage) { if (attributeCollection != null) { attributeCollection.Add(jsEvent, "return confirm('" + chekMessage + "');"); } }
public void TestAddAndCount() { _collection = new AttributeCollection(); // Test adding separate attributes _collection.Add(_a1.Type, _a1); _collection.Add(_a2); Assert.AreEqual(2, _collection.Count()); // Test that you cannot add the same attributes more than once _collection.Add(_a1.Type, _a1); _collection.Add(_a2.Type, _a2); Assert.AreEqual(2, _collection.Count()); }
public void AddAttribute(Attribute attribute) { _attributes.Add(attribute); //KeyedCollection will throw an exception //if there is already an attribute with //the same (case insensitive) name. }
public void AttributeCollectionCanBeSerializedAndDeserialized() { AttributeCollection attributeCollection = new AttributeCollection(); attributeCollection.Add("Test", "test"); JsonSerializer serializer = new JsonSerializer(); serializer.TypeNameHandling = TypeNameHandling.Objects; serializer.Converters.Add(new AttributeCollectionConverter()); MemoryStream memoryStream = new MemoryStream(new byte[9000], true); using (StreamWriter writer = new StreamWriter(memoryStream)) { serializer.Serialize(new JsonTextWriter(writer), attributeCollection); } AttributeCollection deserializedAttributeCollection; memoryStream = new MemoryStream(memoryStream.ToArray()); using (StreamReader reader = new StreamReader(memoryStream)) { deserializedAttributeCollection = (AttributeCollection)serializer.Deserialize(new JsonTextReader(reader), typeof(AttributeCollection)); } Assert.Equal(attributeCollection.GetType(), deserializedAttributeCollection.GetType()); Assert.Equal(attributeCollection.Count, deserializedAttributeCollection.Count); Assert.Equal(attributeCollection.Keys.First(), deserializedAttributeCollection.Keys.First()); Assert.Equal(attributeCollection.Values.First(), deserializedAttributeCollection.Values.First()); }
public static AttributeCollection Map(this PatientAddress patientAddress) { AttributeCollection attrCol = new AttributeCollection(); if (patientAddress.StreetAddressLine != "" && patientAddress.State != "" && patientAddress.City != "" && patientAddress.State != "" && patientAddress.PostalCode != "") { attrCol.Add("crme_fulladdress", patientAddress.StreetAddressLine + " " + patientAddress.City + " " + patientAddress.State + " " + patientAddress.PostalCode); } attrCol.Add("crme_address1", patientAddress.StreetAddressLine); attrCol.Add("crme_city", patientAddress.City); attrCol.Add("crme_addressstate", patientAddress.State); attrCol.Add("crme_addresszip", patientAddress.PostalCode); return(attrCol); }
public virtual AttributeCollection CreateAttributeCollection(SlpReader reader) { var tmp = reader.ReadRawString(); var result = new AttributeCollection(); foreach (var item in tmp.Split(',')) { var pair = item.Split('='); string key = null, value = null; if (pair.Length == 1) { key = reader.Unescape(pair[0]); } else if (pair.Length == 2) { key = reader.Unescape(pair[0]); value = reader.Unescape(pair[1]); } else { throw new ServiceProtocolException(ServiceErrorCode.ParseError); } result.Add(key, value); } return(result); }
public void TestGetSuccess() { _collection = new AttributeCollection(); // Add some test attributes _collection.Add(_a1); _collection.Add(_a2.Type, _a2); // Fetch attributes Attribute actual1 = _collection.Get(_experienceType); Attribute actual2 = _collection.Get(_levelType); // Make sure attributes are the same Assert.AreEqual(_a1, actual1); Assert.AreEqual(_a2, actual2); }
public void DbItem_As_Media_Test() { var created = new DateTime(2012, 01, 01, 0, 0, 0, DateTimeKind.Utc); var item = new AttributeCollection { { "Transformation", "resize:500x500.jpeg" }, { "Duration", 30000 }, { "Created", new DateTimeOffset(created).ToUnixTimeSeconds() } }; item.Add("Hash", new DbValue("FHX8PLDaGoI2hSlwjI1yFvqWTcQ=", DbValueType.B)); var media = item.As <Media>(); Assert.Equal("resize:500x500.jpeg", media.Transformation); Assert.Equal(TimeSpan.FromSeconds(30), media.Duration); Assert.Equal(Convert.FromBase64String("FHX8PLDaGoI2hSlwjI1yFvqWTcQ="), media.Hash); Assert.Equal(created, media.Created); var attributes = AttributeCollection.FromObject(media); Assert.Equal("resize:500x500.jpeg", attributes["Transformation"].Value.ToString()); Assert.Equal(DbValueType.N, attributes["Duration"].Kind); Assert.Equal(DbValueType.N, attributes["Created"].Kind); }
public void TestParse() { var saxHandler = new Mock<ISaxHandler>(); using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream()) { memoryStream.Write(new System.Text.UTF8Encoding().GetBytes(_xmlToParse), 0, _xmlToParse.Length); memoryStream.Position = 0; SaxReaderImpl saxReaderImpl = new SaxReaderImpl(); saxReaderImpl.Parse(new System.IO.StreamReader(memoryStream), saxHandler.Object); } AttributeCollection element3Attributes = new AttributeCollection(); Attribute attr1Attribute = new Attribute(); attr1Attribute.LocalName = "attr1"; attr1Attribute.QName = "attr1"; attr1Attribute.Uri = string.Empty; attr1Attribute.Value = "val1"; element3Attributes.Add("attr1", attr1Attribute); saxHandler.Verify(c => c.StartDocument(), Times.Exactly(1)); saxHandler.Verify(c => c.EndDocument(), Times.Exactly(1)); saxHandler.Verify(c => c.StartElement(string.Empty, "root", "root", new AttributeCollection())); saxHandler.Verify(c => c.StartElement(string.Empty, "element1", "element1", new AttributeCollection())); saxHandler.Verify(c => c.StartElement(string.Empty, "element2", "element2", new AttributeCollection())); saxHandler.Verify(c => c.StartElement(string.Empty, "element3", "element3", element3Attributes)); saxHandler.Verify(c => c.EndElement(string.Empty, "root", "root")); saxHandler.Verify(c => c.EndElement(string.Empty, "element1", "element1")); saxHandler.Verify(c => c.EndElement(string.Empty, "element2", "element2")); saxHandler.Verify(c => c.EndElement(string.Empty, "element3", "element3")); saxHandler.Verify(c => c.Characters(It.IsAny<char[]>(), It.IsAny<int>(), It.IsAny<int>())); }
public void TestAddingAttributeWithValue() { AttributeCollection attributes = new AttributeCollection(); AttributeValue comparisonAttributeValue = new AttributeValue("Value"); attributes.Add("Name", comparisonAttributeValue); Assert.AreEqual<string>(comparisonAttributeValue.Value, attributes["Name"].Value); }
public static void CreateStateFriendlyNameMetaField() { using (MetaClassManagerEditScope scope = DataContext.Current.MetaModel.BeginEdit()) { MetaClass timeTrackingEntry = TimeTrackingEntry.GetAssignedMetaClass(); AttributeCollection attr = new AttributeCollection(); attr.Add(McDataTypeAttribute.StringMaxLength, 255); attr.Add(McDataTypeAttribute.StringIsUnique, false); attr.Add(McDataTypeAttribute.Expression, @"SELECT TOP 1 TTBS.FriendlyName FROM cls_TimeTrackingBlock_State TTBS" + Environment.NewLine + @" JOIN cls_TimeTrackingBlock TTB ON " + Environment.NewLine + @" TTB.mc_StateId = TTBS.TimeTrackingBlock_StateId" + Environment.NewLine + @" AND" + Environment.NewLine + @" TTB.[TimeTrackingBlockId] = AAA.[ParentBlockId]"); MetaField retVal = timeTrackingEntry.CreateMetaField("StateFriendlyName", "State", MetaFieldType.Text, true, "''", attr); scope.SaveChanges(); } }
public void TestAddingWithNullAttribute() { bool exceptionThrown; AttributeCollection attributes = new AttributeCollection(); AttributeValue comparisonAttributeValue = new AttributeValue("Value"); try { attributes.Add(null, comparisonAttributeValue); exceptionThrown = false; } catch (ArgumentNullException) { exceptionThrown = true; } Assert.IsTrue(exceptionThrown); }
public virtual AttributeCollection CreateAttributeCollection(SlpReader reader) { var tmp = reader.ReadRawString(); var result = new AttributeCollection(); foreach (var item in tmp.Split(',')) { var pair = item.Split('='); string key = null, value = null; if (pair.Length == 1) key = reader.Unescape(pair[0]); else if (pair.Length == 2) { key = reader.Unescape(pair[0]); value = reader.Unescape(pair[1]); } else throw new ServiceProtocolException(ServiceErrorCode.ParseError); result.Add(key, value); } return result; }
public void TestUpdatingIdenticalAttribute() { AttributeCollection attributes = new AttributeCollection(); AttributeValue newAttributeValue = new AttributeValue("Test Value"); // Add attribute and attribute value attributes.Add("Test", newAttributeValue); Assert.AreEqual<string>(newAttributeValue.Value, attributes["Test"].Value); // Try updating the attribute with the same value attributes.Update("Test", newAttributeValue); // Ensure that the attribute has an updated value Assert.AreEqual<string>(newAttributeValue.Value, attributes["Test"].Value); }
public void TestEnumeratingCollections() { AttributeCollection attributes = new AttributeCollection(); Assert.AreEqual<int>(0, attributes.Count); attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); int counter = 0; foreach (KeyValuePair<string, AttributeValue> kv in attributes) { System.Diagnostics.Debug.WriteLine(kv.ToString()); counter++; } Assert.IsTrue(counter == 4); }
/// <summary> /// Creates the new meta field. /// </summary> /// <param name="column">The column.</param> /// <returns></returns> public static MetaField CreateNewMetaField(DataColumn column) { if (column == null) throw new ArgumentNullException("column"); MetaField retVal = null; string name = GetFieldName(column); string friendlyName = string.IsNullOrEmpty(column.ColumnName) ? name : column.ColumnName; // TODO: bool isNullable = column.AllowDBNull;// true; if (column.DataType == typeof(Int32) || column.DataType == typeof(Int16)) { #region MetaFieldType.Integer AttributeCollection attr = new AttributeCollection(); string strDefaultValue = "0"; retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.Integer, isNullable, strDefaultValue, attr); #endregion } else if (column.DataType == typeof(Double) || column.DataType == typeof(Single)) { #region MetaFieldType.Float AttributeCollection attr = new AttributeCollection(); string strDefaultValue = "0"; attr.Add(McDataTypeAttribute.DecimalPrecision, 18); attr.Add(McDataTypeAttribute.DecimalScale, 4); retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.Decimal, isNullable, strDefaultValue, attr); #endregion } else if (column.DataType == typeof(DateTime)) { #region MetaFieldType.DateTime AttributeCollection attr = new AttributeCollection(); string defaultValue = isNullable ? string.Empty : "getutcdate()"; //Attr.Add(McDataTypeAttribute.DateTimeMinValue, minValue); //Attr.Add(McDataTypeAttribute.DateTimeMaxValue, maxValue); //attr.Add(McDataTypeAttribute.DateTimeUseUserTimeZone, useUserTimeZone); retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.DateTime, isNullable, defaultValue, attr); #endregion } else if (column.DataType == typeof(Boolean)) { #region MetaFieldType.CheckboxBoolean AttributeCollection attr = new AttributeCollection(); string strDefaultValue = "0"; attr.Add(McDataTypeAttribute.BooleanLabel, friendlyName); retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.CheckboxBoolean, isNullable, strDefaultValue, attr); #endregion } else if (column.DataType == typeof(Guid)) { #region MetaFieldType.Guid AttributeCollection attr = new AttributeCollection(); string defaultValue = isNullable ? string.Empty : "newid()"; retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.Guid, isNullable, defaultValue, attr); #endregion } else // if (column.DataType == typeof(String)) { if (column.MaxLength != -1) // Text { #region MetaFieldType.Text AttributeCollection attr = new AttributeCollection(); string strDefaultValue = isNullable ? string.Empty : "''"; attr.Add(McDataTypeAttribute.StringMaxLength, column.MaxLength); attr.Add(McDataTypeAttribute.StringIsUnique, column.Unique); retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.Text, isNullable, strDefaultValue, attr); #endregion } //else if (column.MaxLength == -1) //{ // #region MetaFieldType.Text 255 Length // AttributeCollection attr = new AttributeCollection(); // string strDefaultValue = isNullable ? string.Empty : "''"; // attr.Add(McDataTypeAttribute.StringMaxLength, 255); // attr.Add(McDataTypeAttribute.StringIsUnique, false); // retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.Text, isNullable, strDefaultValue, attr); // #endregion //} else // LongText (Default) { #region MetaFieldType.LongText AttributeCollection attr = new AttributeCollection(); string strDefaultValue = isNullable ? string.Empty : "''"; attr.Add(McDataTypeAttribute.StringLongText, true); retVal = CreateNewMetaField(name, friendlyName, MetaFieldType.LongText, isNullable, strDefaultValue, attr); #endregion } } return retVal; }
public void TestCollectionChangedWithUpdatee() { AttributeCollection attributes = new AttributeCollection(); bool eventRaised = false; NotifyCollectionChangedAction action = NotifyCollectionChangedAction.Reset; int newIndex = -1; string newAttributeName = string.Empty; AttributeValue newAttributeValue = null; int oldIndex = -1; string oldAttributeName = string.Empty; AttributeValue oldAttributeValue = null; attributes.Add("Test1", new AttributeValue("Test Value1")); // Setup the event handler attributes.CollectionChanged += (object sender, NotifyCollectionChangedEventArgs e) => { action = e.Action; newAttributeName = e.NewItems != null ? ((KeyValuePair<string, AttributeValue>)e.NewItems[0]).Key : string.Empty; newAttributeValue = e.NewItems != null ? ((KeyValuePair<string, AttributeValue>)e.NewItems[0]).Value : null; newIndex = e.NewStartingIndex; oldAttributeName = e.OldItems != null ? ((KeyValuePair<string, AttributeValue>)e.OldItems[0]).Key : string.Empty; oldAttributeValue = e.OldItems != null ? ((KeyValuePair<string, AttributeValue>)e.OldItems[0]).Value : null; oldIndex = e.OldStartingIndex; eventRaised = true; }; // Make change to property EnqueueCallback(() => attributes.Update("Test1", new AttributeValue("Updated Value1"))); // Wait for event to complete EnqueueConditional(() => eventRaised != false); // Test that event was appropriately fires and handled EnqueueCallback(() => Assert.AreEqual<string>("Test1", oldAttributeName)); EnqueueCallback(() => Assert.AreEqual<string>("Test1", newAttributeName)); EnqueueCallback(() => Assert.AreEqual<string>("Test Value1", oldAttributeValue.Value)); EnqueueCallback(() => Assert.AreEqual<string>("Updated Value1", newAttributeValue.Value)); EnqueueCallback(() => Assert.AreEqual<NotifyCollectionChangedAction>(action, NotifyCollectionChangedAction.Replace)); // Reset testing fields EnqueueCallback(() => action = NotifyCollectionChangedAction.Reset); EnqueueCallback(() => newAttributeName = string.Empty); EnqueueCallback(() => newAttributeValue = null); EnqueueCallback(() => newIndex = -1); EnqueueCallback(() => oldAttributeName = string.Empty); EnqueueCallback(() => oldAttributeValue = null); EnqueueCallback(() => oldIndex = -1); EnqueueCallback(() => eventRaised = false); EnqueueTestComplete(); }
public void TestAttributePropertyChangedEvent() { AttributeCollection attributes = new AttributeCollection(); object oldValue = null; object newValue = null; string propertyChanged = string.Empty; // Setup the event handler attributes.AttributeValuePropertyChanged += (object sender, Berico.Common.Events.PropertyChangedEventArgs<object> e) => { oldValue = e.OldValue; newValue = e.NewValue; propertyChanged = e.PropertyName; }; // Add some attributes to the collection attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); // Retrieve one of the attributes to test AttributeValue testAttributeValue = attributes.GetAttributeValue("Test3"); // Make change to property EnqueueCallback(() => testAttributeValue.Value = "New Value"); // Wait for event to complete EnqueueConditional(() => propertyChanged != string.Empty); // Test that event was appropriately fires and handled EnqueueCallback(() => Assert.AreEqual<string>("Value", propertyChanged)); EnqueueCallback(() => Assert.AreEqual<string>("New Value", newValue as string)); EnqueueCallback(() => Assert.AreEqual<string>("Test Value3", oldValue as string)); // Reset testing fields EnqueueCallback(() => propertyChanged = string.Empty); EnqueueCallback(() => oldValue = null); EnqueueCallback(() => newValue = null); EnqueueTestComplete(); }
public void TestEnumeratingAttributeValues() { AttributeCollection attributes = new AttributeCollection(); Assert.AreEqual<int>(0, attributes.Count); attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); List<AttributeValue> attributeValues = new List<AttributeValue>(attributes.AttributeValues); for (int i = 1; i <= attributeValues.Count; i++) { Assert.AreEqual<string>(attributeValues[i - 1].Value, "Test Value" + i); } }
public void TestUpdatingAttribute() { AttributeCollection attributes = new AttributeCollection(); AttributeValue newAttributeValue = new AttributeValue("Test Value"); // Add attribute and attribute value attributes.Add("Test", newAttributeValue); Assert.AreEqual<string>(newAttributeValue.Value, attributes["Test"].Value); AttributeValue updatedAttributeValue = new AttributeValue("New Test Value"); // Add attribute and attribute value attributes.Update("Test", updatedAttributeValue); // Ensure that the attribute has an updated value Assert.AreEqual<string>(updatedAttributeValue.Value, attributes["Test"].Value); }
public void TestSuccessfullCheckIfAttributeExists() { AttributeCollection attributes = new AttributeCollection(); AttributeValue newAttributeValue = new AttributeValue("Test Value"); // Add the attribute attributes.Add("Test", newAttributeValue); Assert.IsTrue(attributes.ContainsAttribute("Test")); }
public void TestRemovingInvalidAttribute() { AttributeCollection attributes = new AttributeCollection(); attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); Assert.IsFalse(attributes.Remove("Test5")); }
public void TestCountingCollectionItems() { AttributeCollection attributes = new AttributeCollection(); Assert.AreEqual<int>(0, attributes.Count); attributes.Add("Test1", new AttributeValue("Test Value1")); attributes.Add("Test2", new AttributeValue("Test Value2")); attributes.Add("Test3", new AttributeValue("Test Value3")); attributes.Add("Test4", new AttributeValue("Test Value4")); Assert.AreEqual<int>(4, attributes.Count); }
public void TestGettingAnAttributeThatExists() { AttributeCollection attributes = new AttributeCollection(); AttributeValue newAttributeValue = new AttributeValue("Test Value"); // Add the attribute attributes.Add("Test", newAttributeValue); // Check if the attribute exists (by name) Assert.AreEqual<AttributeValue>(attributes.GetAttributeValue("Test"), newAttributeValue); Assert.AreEqual<AttributeValue>(attributes["Test"], newAttributeValue); // Check if the attribute exists (by attribute) Assert.AreEqual<AttributeValue>(attributes.GetAttributeValue("Test"), newAttributeValue); Assert.AreEqual<AttributeValue>(attributes["Test"], newAttributeValue); }