public void RemovePropertyStringTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop1 = new StringProperty("test", "orange");
Property prop2 = new StringProperty("two", "number");
collection.Add(prop1);
collection.Add(prop2);
collection.PropertyRemoved += (s, e) =>
{
Assert.AreSame(prop1, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsFalse(collection.Contains(prop1));
Assert.IsTrue(collection.Contains(prop2));
};
_eventsFired = EventFlags.None;
collection.Remove("test");
Assert.AreEqual(EventFlags.PropertyRemoved | EventFlags.Modified, _eventsFired);
}
public void RenamePropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyRenamed += (s, e) =>
{
Assert.AreEqual("test", e.OldName);
Assert.AreEqual("two", e.NewName);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsTrue(collection.Contains(prop));
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Name = "two";
Assert.AreEqual(EventFlags.PropertyRenamed | EventFlags.Modified, _eventsFired);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("digest_timeout"))
{
digest_timeout = Convert.ToInt64(props["digest_timeout"]);
props.Remove("digest_timeout");
}
if (props.Contains("desired_avg_gossip"))
{
desired_avg_gossip = Convert.ToInt64(props["desired_avg_gossip"]);
props.Remove("desired_avg_gossip");
}
if (props.Contains("stability_delay"))
{
stability_delay = Convert.ToInt64(props["stability_delay"]);
props.Remove("stability_delay");
}
if (props.Contains("max_gossip_runs"))
{
max_gossip_runs = Convert.ToInt32(props["max_gossip_runs"]);
num_gossip_runs = max_gossip_runs;
props.Remove("max_gossip_runs");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("retransmit_timeout"))
{
String[] strArray = Convert.ToString(props["retransmit_timeout"]).Split(new Char[] { ',' });
for (int i = 0; i < strArray.Length; i++)
{
retransmit_timeout[i] = Convert.ToInt64(strArray[i]);
}
props.Remove("retransmit_timeout");
}
if (props.Contains("gc_lag"))
{
gc_lag = Convert.ToInt32(props["gc_lag"]);
if (gc_lag < 1)
{
if (Trace.trace)
{
Trace.error("NAKACK.setProperties()", "gc_lag has to be at least 1 (set to 10)");
}
gc_lag = 10;
}
props.Remove("gc_lag");
}
if (props.Contains("max_xmit_size"))
{
max_xmit_size = Convert.ToInt64(props["max_xmit_size"]);
props.Remove("max_xmit_size");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("timeout"))
{
timeout = Convert.ToInt64(props["timeout"]);
props.Remove("timeout");
}
if (props.Contains("num_msgs"))
{
num_msgs = Convert.ToInt32(props["num_msgs"]);
if (num_msgs <= 0)
{
if (Trace.trace)
{
Trace.warn("VERIFY_SUSPECT.setProperties()", "num_msgs is invalid (" +
num_msgs + "): setting it to 1");
}
num_msgs = 1;
}
props.Remove("num_msgs");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
public void ModifyPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyModified += (s, e) =>
{
Assert.AreSame(prop, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsTrue(collection.Contains("test"));
Assert.IsTrue(collection.Contains(prop));
Assert.AreEqual("blue", e.Property.ToString());
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Value = "blue";
Assert.AreEqual(EventFlags.PropertyModified | EventFlags.Modified, _eventsFired);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("mcast_addr"))
{
mcast_addr.IP = IPAddress.Parse(Convert.ToString(props["mcast_addr"]));
props.Remove("mcast_addr");
}
if (props.Contains("mcast_port"))
{
mcast_addr.Port = Convert.ToInt32(props["mcast_port"]);
props.Remove("mcast_port");
}
if (props.Contains("bind_addr"))
{
bind_addr.IP = IPAddress.Parse(Convert.ToString(props["bind_addr"]));
props.Remove("bind_addr");
}
if (props.Contains("bind_port"))
{
bind_addr.Port = Convert.ToInt32(props["mcast_port"]);
props.Remove("mcast_port");
}
if (props.Contains("ip_ttl"))
{
ip_ttl = Convert.ToInt32(props["ip_ttl"]);
props.Remove("ip_ttl");
}
if (props.Contains("bind_port"))
{
bind_addr.Port = Convert.ToInt32(props["bind_port"]);
props.Remove("bind_port");
}
if (props.Contains("mcast_send_buf_size"))
{
mcast_send_buf_size = Convert.ToInt32(props["mcast_send_buf_size"]);
props.Remove("mcast_send_buf_size");
}
if (props.Contains("mcast_recv_buf_size"))
{
mcast_recv_buf_size = Convert.ToInt32(props["mcast_recv_buf_size"]);
props.Remove("mcast_recv_buf_size");
}
if (props.Contains("ucast_send_buf_size"))
{
ucast_send_buf_size = Convert.ToInt32(props["ucast_send_buf_size"]);
props.Remove("ucast_send_buf_size");
}
if (props.Contains("ucast_recv_buf_size"))
{
ucast_recv_buf_size = Convert.ToInt32(props["ucast_recv_buf_size"]);
props.Remove("ucast_recv_buf_size");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("timeout"))
{
String[] strArray = Convert.ToString(props["timeout"]).Split(new Char[] { ',' });
for (int i = 0; i < strArray.Length; i++)
{
timeout[i] = Convert.ToInt64(strArray[i]);
}
props.Remove("timeout");
}
if (props.Contains("window_size"))
{
window_size = Convert.ToInt32(props["window_size"]);
props.Remove("window_size");
}
if (props.Contains("min_threshold"))
{
min_threshold = Convert.ToInt32(props["min_threshold"]);
props.Remove("min_threshold");
}
if (props.Count > 0)
{
return(false);
}
// Some sanity checks
if ((window_size > 0 && min_threshold <= 0) || (window_size <= 0 && min_threshold > 0))
{
if (Trace.trace)
{
Trace.error("UNICAST.setProperties()",
"window_size and min_threshold have to be both set if one of them is set");
}
return(false);
}
if (window_size > 0 && min_threshold > 0 && window_size < min_threshold)
{
if (Trace.trace)
{
Trace.error("UNICAST.setProperties()", "min_threshold (" + min_threshold +
") has to be less than window_size (" + window_size + ")");
}
return(false);
}
return(true);
}
/// <summary>
/// Get a value typed property for the specified attribute name.
/// </summary>
/// <typeparam name="T">The return value type that should be returned.</typeparam>
/// <param name="properties">The properties to extract the value from.</param>
/// <param name="attributeName">The name of the attribute to get the property value for.</param>
/// <param name="index">The array index of the proeprty we want to return (all properties are multi-valued).</param>
/// <returns>The typed value of the property at the specified index if it can be found and cast, otherwise null/default.</returns>
public static T?GetValue <T>(this PropertyCollection properties, string attributeName, int index = 0) where T : struct
{
var result = new T?();
if (properties.Contains(attributeName) && properties[attributeName].Count >= index)
{
try
{
if (typeof(T) == typeof(Guid))
{
var guid = properties.GetReference <string>(attributeName, index);
result = (T)(object)new Guid(guid);
}
else
{
result = (T)properties[attributeName][index];
}
}
catch
{
// NOTE: Ignore the error in casting, we will return the default of T?.
}
}
return(result);
}
public void Contains_KnownProperty()
{
var properties = new PropertyBase[] { CreateProperty() };
var propertyCollection = new PropertyCollection(properties);
Assert.That(propertyCollection.Contains("Scalar"), Is.True);
}
public Enemy Spawn(EnemyType type, Vector3 pos, PropertyCollection props)
{
Enemy e = null;
switch (type)
{
case EnemyType.Asteroid:
e = new Asteroid(pos, spriteSheets["Asteroid"]);
break;
case EnemyType.Omega:
e = new Omega(pos, spriteSheets["Omega"]);
break;
case EnemyType.Turret:
e = new Turret(pos, spriteSheets["Turret"], props.Contains("Inverted"));
break;
case EnemyType.Squid:
e = new Squid(pos, spriteSheets["Squid"]);
break;
}
Enemies.Add(e);
return(e);
}
public void Contains_UnkownProperty()
{
var properties = new PropertyBase[] { CreateProperty() };
var propertyCollection = new PropertyCollection(properties);
Assert.That(propertyCollection.Contains("Invalid"), Is.False);
}
private Dictionary <string, object> GetGroupsMember(PropertyCollection subgroupProps, Dictionary <string, object> subgroup)
{
if (subgroupProps.Contains("member"))
{
var subgroupMember = new List <Dictionary <string, object> >();
foreach (Object subgroupProp in subgroupProps["member"])
{
DirectoryEntry sub_gpMemberEntry = new DirectoryEntry("LDAP://" + subgroupProp);
var new_subgroupProps = sub_gpMemberEntry.Properties;
subgroupMember.Add(GetGroupsMember(new_subgroupProps, subgroup));
}
foreach (Object subgroupProp in subgroupProps["cn"])
{
subgroup.Add(subgroupProp.ToString(), subgroupMember);
}
return(subgroup);
}
else
{
var userDetail = new Dictionary <string, object>();
var userProps = subgroupProps;
string USERNAME_FIELD = !string.IsNullOrEmpty(AMSCore.WebConfigReadKey("AD_USERNAME_FIELD")) ? AMSCore.WebConfigReadKey("AD_USERNAME_FIELD") : "SAMAccountName";
object obVal = userProps[USERNAME_FIELD].Value;
if (null != obVal)
{
userDetail.Add(USERNAME_FIELD, obVal.ToString());
}
return(userDetail);
}
}
public static object getpropertyvalue(PropertyCollection Properties, string PropertyName)
{
if (Properties.Contains(PropertyName))
{
if (Properties[PropertyName].Value != null)
{
try
{
//PropertyValueCollection ValueCollection = Properties[PropertyName];
//for (int i = 0; i < ValueCollection.Count; i++)
//{
// if (i == 0)
// {
// result[count] = ValueCollection[i].ToString();
// }
// else
// {
// result[count] += "|" + ValueCollection[i].ToString();
// }
//}
return(Properties[PropertyName].Value);
}
catch (Exception ex)
{
}
}
}
return(null);
}
public void Property_Contains_Case_Insensitive_Compare()
{
var collection = new PropertyCollection();
collection.Add(new Property(new PropertyType("propEditor", DataTypeDatabaseType.Nvarchar, "test")));
Assert.IsTrue(collection.Contains("Test"));
}
public PropertyCategory LookupCategory(string propertyName)
{
if (_classManager.ContainsDefinition(propertyName))
{
return(PropertyCategory.Predefined);
}
if (_custom.Contains(propertyName))
{
return(PropertyCategory.Custom);
}
if (_customParent != null && _customParent.PropertyManager.CustomProperties.Contains(propertyName))
{
return(PropertyCategory.Inherited);
}
return(PropertyCategory.None);
}
/// <summary>
/// Get properties
/// </summary>
/// <param name="directoryEntryProperties"></param>
/// <param name="property"></param>
/// <returns></returns>
internal static XElement getProperty(PropertyCollection directoryEntryProperties, string property)
{
if (directoryEntryProperties.Contains(property))
{
return(new XElement((XName)property, (object)directoryEntryProperties[property].Value.ToString()));
}
return(new XElement((XName)property, (object)""));
}
/// <summary>
/// Gets a collection of reference typed properties for the specified attribute name.
/// </summary>
/// <typeparam name="T">The type we expect to be contained in the collection.</typeparam>
/// <param name="properties">The properties to extract our values from.</param>
/// <param name="attributeName">The name of the attribute to get the property values for.</param>
/// <returns>
/// A collection of properties, or null/empty if they cannot be found.
/// </returns>
/// <remarks>The collection may still contain null values, as we are using the friendly 'as' casting method.</remarks>
public static IEnumerable <T> GetCollectionReference <T>(this PropertyCollection properties, string attributeName) where T : class
{
if (properties.Contains(attributeName) && properties[attributeName].Count > 0)
{
return((from object attribute in properties[attributeName] select attribute as T).ToList());
}
return(Enumerable.Empty <T>());
}
public void Property_Contains_Case_Insensitive_Compare()
{
var collection = new PropertyCollection
{
new Property(new PropertyType(TestHelper.ShortStringHelper, "propEditor", ValueStorageType.Nvarchar, "test")),
};
Assert.IsTrue(collection.Contains("Test"));
}
/// <summary>
/// Removes and sets all generic properties of a Protocol, then passes remainder of properties on to implementation
/// </summary>
/// <param name="properties">Collection of properties</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public bool setPropertiesInternal(PropertyCollection properties)
{
this.props = properties;
if (props.Contains("down_thread"))
{
down_thread = Convert.ToBoolean(props["down_thread"]);
props.Remove("down_thread");
}
if (props.Contains("up_thread"))
{
up_thread = Convert.ToBoolean(props["up_thread"]);
props.Remove("up_thread");
}
return(setProperties(props));
}
public void AddPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop = new StringProperty("test", "orange");
collection.PropertyAdded += (s, e) =>
{
Assert.AreSame(prop, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsTrue(collection.Contains("test"));
Assert.IsTrue(collection.Contains(prop));
};
collection.Add(prop);
Assert.AreEqual(EventFlags.PropertyAdded | EventFlags.Modified, _eventsFired);
}
private static string getpropertyvalue(PropertyCollection Properties, string PropertyName)
{
if (Properties.Contains(PropertyName))
{
if (Properties[PropertyName].Value != null)
{
return(Properties[PropertyName].Value.ToString());
}
}
return("");
}
public void AddPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop = new StringProperty("test", "orange");
collection.PropertyAdded += (s, e) =>
{
Assert.AreSame(prop, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsTrue(collection.Contains("test"));
Assert.IsTrue(collection.Contains(prop));
};
collection.Add(prop);
Assert.AreEqual(EventFlags.PropertyAdded | EventFlags.Modified, _eventsFired);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("num_initial_members"))
{
num_initial_members = Convert.ToInt32(props["num_initial_members"]);
props.Remove("num_initial_members");
}
if (props.Contains("timeout"))
{
timeout = Convert.ToInt64(props["timeout"]);
props.Remove("timeout");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
private static string GetPropertyValue(string name, PropertyCollection propertyCollection)
{
if (propertyCollection.Contains(name))
{
PropertyValueCollection propertyValueCollection = propertyCollection[name];
if (propertyValueCollection.Count > 0)
{
return(propertyValueCollection[0].ToString());
}
}
return(string.Empty);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("timeout"))
{
timeout = Convert.ToInt64(props["timeout"]);
props.Remove("timeout");
}
if (props.Contains("max_tries"))
{
max_tries = Convert.ToInt32(props["max_tries"]);
props.Remove("max_tries");
}
if (props.Contains("shun"))
{
shun = Convert.ToBoolean(props["shun"]);
props.Remove("shun");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("up"))
{
probUp = Convert.ToDouble(props["up"]);
props.Remove("up");
}
if (props.Contains("down"))
{
probDown = Convert.ToDouble(props["down"]);
props.Remove("down");
}
if (props.Contains("excludeItself"))
{
excludeItself = Convert.ToBoolean(props["excludeItself"]);
props.Remove("excludeItself");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Gets the value for the specified attribute name.
/// </summary>
/// <typeparam name="T">The return type the value should be cast to.</typeparam>
/// <param name="properties">The properties to extract the value from.</param>
/// <param name="attributeName">The name of the attribute to get the property value for.</param>
/// <param name="index">The array index of the property we want to return (all properties are multi-valued).</param>
/// <returns>The typed value of the property at the specified index if it can be found, otherwise null/empty.</returns>
public static T GetReference <T>(this PropertyCollection properties, string attributeName, int index = 0) where T : class
{
if (properties.Contains(attributeName) && properties[attributeName].Count >= index)
{
return(properties[attributeName][index] as T);
}
if (typeof(T) == typeof(string))
{
// TODO: Is this really needed if the requestor is aware we return null and is using the null-conditional operator '?.'
// We couldn't find what the requestor asked for, but they wanted a string.
return((T)(object)string.Empty);
}
return(null);
}
private static string GetFirstValue(PropertyCollection res, string key)
{
if (res.Contains(key))
{
var values = res[key];
if (values.Count > 0 && values[0] != null)
{
return(values[0].ToString());
}
else
{
Log.Warn("域中此字段无值：" + key);
}
}
else
{
Log.Warn("域中不包含此字段：" + key);
}
return(String.Empty);
}
/// <summary>
/// Adds a key to a concrete <see cref="PropertyCollection"/> instance, checking
/// if duplicate keys are allowed in the configuration
/// </summary>
/// <param name="key">
/// Key name
/// </param>
/// <param name="value">
/// Key's value
/// </param>
/// <param name="keyDataCollection">
/// <see cref="Property"/> collection where the key should be inserted
/// </param>
/// <param name="sectionName">
/// Name of the section where the <see cref="PropertyCollection"/> is contained.
/// Used only for logging purposes.
/// </param>
private void AddKeyToKeyValueCollection(string key, string value, PropertyCollection keyDataCollection, string sectionName)
{
// Check for duplicated keys
if (keyDataCollection.Contains(key))
{
// We already have a key with the same name defined in the current section
HandleDuplicatedKeyInCollection(key, value, keyDataCollection, sectionName);
}
else
{
// Save the keys
keyDataCollection.Add(key, value);
}
if (Configuration.ParseComments)
{
keyDataCollection.FindByKey(key).Comments = CurrentCommentListTemp;
CurrentCommentListTemp.Clear();
}
}
/// <summary>
/// Sets the properties specified in the configuration string
/// </summary>
/// <param name="props">Properties to set</param>
/// <returns>False if properties were specified that are not know, otherwise true</returns>
public override bool setProperties(PropertyCollection props)
{
if (props.Contains("shun"))
{
shun = Convert.ToBoolean(props["shun"]);
props.Remove("shun");
}
if (props.Contains("print_local_addr"))
{
print_local_addr = Convert.ToBoolean(props["print_local_addr"]);
props.Remove("print_local_addr");
}
if (props.Contains("join_timeout"))
{
join_timeout = Convert.ToInt64(props["join_timeout"]);
props.Remove("join_timeout");
}
if (props.Contains("join_retry_timeout"))
{
join_retry_timeout = Convert.ToInt64(props["join_retry_timeout"]);
props.Remove("join_retry_timeout");
}
if (props.Contains("leave_timeout")) // time to wait until coord responds to LEAVE req.
{
leave_timeout = Convert.ToInt64(props["leave_timeout"]);
props.Remove("leave_timeout");
}
if (props.Contains("digest_timeout")) // time to wait for GET_DIGEST_OK from PBCAST
{
digest_timeout = Convert.ToInt64(props["digest_timeout"]);
props.Remove("digest_timeout");
}
if (props.Contains("disable_initial_coord")) // time to wait for GET_DIGEST_OK from PBCAST
{
disable_initial_coord = Convert.ToBoolean(props["disable_initial_coord"]);
props.Remove("disable_initial_coord");
}
if (props.Count > 0)
{
return(false);
}
return(true);
}
public void RemovePropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop1 = new StringProperty("test", "orange");
Property prop2 = new StringProperty("two", "number");
collection.Add(prop1);
collection.Add(prop2);
collection.PropertyRemoved += (s, e) =>
{
Assert.AreSame(prop1, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsFalse(collection.Contains(prop1));
Assert.IsTrue(collection.Contains(prop2));
};
_eventsFired = EventFlags.None;
collection.Remove(prop1);
Assert.AreEqual(EventFlags.PropertyRemoved | EventFlags.Modified, _eventsFired);
}
/// <summary>
/// Gets an Object from a Dynamic Entity's Property collection
/// </summary>
/// <param name="col"></param>
/// <param name="propertyName"></param>
/// <returns></returns>
private object GetObjectFromProperty(PropertyCollection col, string propertyName)
{
return col.Contains(propertyName) ? col[propertyName] : null;
}
public BuildContext(String properties, ParsedPath contentFilePath)
{
ContentFilePath = contentFilePath;
ContentFile = new ContentFileV4();
ContentFile.Load(ContentFilePath);
WriteMessage("Read content file '{0}'", ContentFilePath);
Properties = new PropertyCollection();
// Start with the environment
Properties.AddFromEnvironment();
// Set defaults for important locations
Properties.Set("BuildContentDir", new ParsedPath(Assembly.GetExecutingAssembly().Location, PathType.File).VolumeAndDirectory.ToString());
Properties.Set("ContentFileDir", contentFilePath.VolumeAndDirectory);
Properties.Set("InputDir", contentFilePath.VolumeAndDirectory);
Properties.Set("OutputDir", contentFilePath.VolumeAndDirectory);
// Now override with from content file
Properties.AddFromList(ContentFile.Properties.Select(nv => new KeyValuePair<string, string>(nv.Name.Value, nv.Value.Value)));
// Now override with command line
Properties.AddFromString(properties);
// Add content file hash location if not set already
if (!Properties.Contains("ContentFileHashes"))
{
ParsedPath path = new ParsedPath(Properties.GetRequiredValue("OutputDir"), PathType.Directory);
Properties.Set("ContentHashesFile", path.Append(ContentFilePath.FileAndExtension + ".hashes", PathType.File));
}
ContentFileHashesPath = new ParsedPath(Properties.GetRequiredValue("ContentHashesFile"), PathType.File).MakeFullPath();
ContentFileWriteTime = File.GetLastWriteTime(this.ContentFilePath);
// Create a hash of all the things than can affect the build
SHA1 sha1 = SHA1.Create();
StringBuilder sb = new StringBuilder();
foreach (var rawAssembly in ContentFile.CompilerAssemblies)
{
sb.Append(rawAssembly.Value);
}
foreach (var rawProperty in ContentFile.Properties)
{
sb.Append(rawProperty.Name.Value);
sb.Append(rawProperty.Value.Value);
}
foreach (var rawCompilerSettings in this.ContentFile.CompilerSettings)
{
sb.Append(rawCompilerSettings.Name);
foreach (var extension in rawCompilerSettings.CompilerExtensions)
{
foreach (var input in extension.Inputs)
sb.Append(input.Value);
foreach (var output in extension.Outputs)
sb.Append(output.Value);
}
foreach (var parameter in rawCompilerSettings.Parameters.KeyValues)
{
sb.Append(parameter.Key.Value);
sb.Append(parameter.Value.ToString());
}
}
GlobalHash = BitConverter.ToString(sha1.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()))).Replace("-", "");
LoadCompilerClasses();
}
public Enemy Spawn(EnemyType type, Vector3 pos, PropertyCollection props)
{
Enemy e = null;
switch (type)
{
case EnemyType.Asteroid:
e = new Asteroid(pos, spriteSheets["Asteroid"]);
break;
case EnemyType.Omega:
e = new Omega(pos, spriteSheets["Omega"]);
break;
case EnemyType.Turret:
e = new Turret(pos, spriteSheets["Turret"], props.Contains("Inverted"));
break;
case EnemyType.Squid:
e = new Squid(pos, spriteSheets["Squid"]);
break;
}
Enemies.Add(e);
return e;
}
public void ModifyPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyModified += (s, e) =>
{
Assert.AreSame(prop, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsTrue(collection.Contains("test"));
Assert.IsTrue(collection.Contains(prop));
Assert.AreEqual("blue", e.Property.ToString());
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Value = "blue";
Assert.AreEqual(EventFlags.PropertyModified | EventFlags.Modified, _eventsFired);
}
public void RenamePropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyRenamed += (s, e) =>
{
Assert.AreEqual("test", e.OldName);
Assert.AreEqual("two", e.NewName);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsTrue(collection.Contains(prop));
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Name = "two";
Assert.AreEqual(EventFlags.PropertyRenamed | EventFlags.Modified, _eventsFired);
}
