public void ShouldGenerateNameWithPropForList()
 {
     var info = new PropertyInfo(new ClassInfo { XmlName = "someClass" });
     info.XmlName = "someClass";
     info.IsList = true;
     Assert.That(info.GetCodeName(), Is.EqualTo("SomeClassProps"));
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="LocalizedPropertyStringLengthRule"/> class.
        /// </summary>
        /// <param name="primaryProperty">
        /// The primary property.
        /// </param>
        /// <param name="mainProperty">
        /// The main property.
        /// </param>
        /// <param name="maxLength">
        /// The max length.
        /// </param>
        /// <param name="propertyDisplayName">
        /// The property display name.
        /// </param>
        /// <param name="resourceManager">
        /// The resource manager.
        /// </param>
        /// <param name="localizationName">
        /// The localization name.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="primaryProperty"/> parameter is null.
        /// </exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// The <paramref name="maxLength"/> is less than zero.
        /// </exception>
        public LocalizedPropertyStringLengthRule(
            PropertyInfo<string> primaryProperty,
            PropertyInfo<string> mainProperty,
            int maxLength,
            string propertyDisplayName,
            ResourceManager resourceManager,
            string localizationName)
            : base(primaryProperty)
        {
            if (primaryProperty == null)
                throw new ArgumentNullException("primaryProperty");

            if (maxLength < 0)
                throw new ArgumentOutOfRangeException("maxLength");

            _primaryProperty = primaryProperty;
            _maxLength = maxLength;
            _propertyDisplayName = propertyDisplayName;
            _resourceManager = resourceManager;
            _mainProperty = mainProperty;
            _localizationName = localizationName;

            InputProperties = InputProperties ?? new List<IPropertyInfo>();
            InputProperties.Add(primaryProperty);

            if (_mainProperty != null)
                AffectedProperties.Add(_mainProperty);
        }

    public static bool CanEdit(PropertyInfo property)
    {
        if (!property.CanRead)
        {
            return false;
        }

        var browsableAttribute = (BrowsableAttribute)Attribute.GetCustomAttribute(property, typeof(BrowsableAttribute), false);
        if (browsableAttribute != null && !browsableAttribute.Browsable)
        {
            return false;
        }

        var designerSerializationVisibilityAttribute = (DesignerSerializationVisibilityAttribute)Attribute.GetCustomAttribute(property, typeof(DesignerSerializationVisibilityAttribute), false);
        if (designerSerializationVisibilityAttribute != null && designerSerializationVisibilityAttribute.Visibility == DesignerSerializationVisibility.Hidden)
        {
            return false;
        }

        if (!property.CanWrite && !typeof(System.Collections.IList).IsAssignableFrom(property.PropertyType))
        {
            return false;
        }

        return true;
    }

 public void ShouldGenerateNameForListWithSAtTheEnd()
 {
     var info = new PropertyInfo(new ClassInfo { XmlName = "someClass" });
     info.XmlName = "tests";
     info.IsList = true;
     Assert.That(info.GetCodeName(), Is.EqualTo("Tests"));
 }

        private static string ConvertToPropertyString(string entityName, PropertyInfo property)
        {
            string typeName = ConvertTypeName(property);

            var propertyString = string.Format(
            @"public static readonly Property<{0}> {1}Property = P<{2}>.Register(e => e.{1});
            ",
            typeName, property.Name, entityName);
            if (!string.IsNullOrEmpty(property.Comment))
            {
                propertyString += string.Format(
            @"/// <summary>
            /// {0}
            /// </summary>
            ", property.Comment);
            }
            propertyString += string.Format(
            @"public {0} {1}
            {{
            get {{ return this.GetProperty({1}Property); }}
            set {{ this.SetProperty({1}Property, value); }}
            }}", typeName, property.Name);

            return propertyString;
        }

 void ProcessRes(PropertyInfo pi)
 {
     var obj = pi.GetValue(null, null);
     var type = obj.GetType();
     if(type == typeof(string))
     {
         var item = new RString();
         item.name = pi.Name;
         item.value = obj as string;
         listString.Add(item);
     }
     else if (type == typeof(Texture2D))
     {
         var item = new RTexture();
         item.name = pi.Name;
         item.value = obj as Texture2D;
         listTexture.Add(item);
     }
     else
     {
         var item = new RUnknown();
         item.name = pi.Name;
         item.type = type.Name;
         item.value = obj.ToString();
         listUnknown.Add(item);
     }
 }

        public Class Parse(String json, String className)
        {
            Class result = new Class(AccessModifier.Public, className);

            var oo = JsonConvert.DeserializeObject(json);
            var c = new ClassInfo(className);
            if (oo is JArray)
            {
                foreach (var jo in (JArray)oo)
                {
                    if (jo is JObject)
                    {
                        SetProperties(c, (JObject)jo);
                    }
                    else if (jo is JValue)
                    {
                        var pi = new PropertyInfo();
                        pi.Validate(jo);
                        return new Class(AccessModifier.Public, pi.GetCSharpTypeName());
                    }
                }
            }
            else if (oo is JObject)
            {
                SetProperties(c, (JObject)oo);
            }
            SetProperties(result, c);

            return result;
        }

 public PropertyAccessor(PropertyInfo propertyInfo)
     : base(propertyInfo)
 {
     _hasSetter = (propertyInfo.GetSetMethod(true) != null);
     if (_hasSetter)
         _lateBoundPropertySet = DelegateFactory.CreateSet(propertyInfo);
 }

        private static string ConvertTypeName(PropertyInfo property)
        {
            Type type = property.Type;
            if (type == typeof(decimal))
            {
                type = typeof(double);
            }

            string typeName = type.Name;
            if (type != typeof(string))
            {
                if (type == typeof(int))
                {
                    typeName = "int";
                }
                else if (type == typeof(double))
                {
                    typeName = "double";
                }
                else if (type == typeof(bool))
                {
                    typeName = "bool";
                }
                typeName += "?";
            }
            else
            {
                typeName = "string";
            }
            return typeName;
        }

 public void boolField(object pObject, PropertyInfo pPropertyInfo)
 {
     bool lValue = (bool)pPropertyInfo.GetValue(pObject, null);
     content.text="";
     bool lNewValue = GUILayout.Toggle(lValue, content);
     if(lValue!=lNewValue)
         pPropertyInfo.SetValue(pObject, lNewValue, null);
 }

 public PropertyOperation(PropertyInfo propertyInfo)
 {
     if (propertyInfo == null)
     {
         throw new ArgumentNullException("pi");
     }
     this.propertyInfo = propertyInfo;
 }

 public ValueTypePropertyAccessor(PropertyInfo propertyInfo)
     : base(propertyInfo)
 {
     var setMethod = propertyInfo.GetSetMethod(true);
     _hasSetter = (setMethod != null);
     if (_hasSetter)
         _lateBoundPropertySet = setMethod;
 }

 public override Property Eval(Property[] args, PropertyInfo pInfo)
 {
     string propName = args[0].GetString();
     if (propName == null)
     {
         throw new PropertyException("Incorrect parameter to inherited-property-value function");
     }
     return pInfo.getPropertyList().GetInheritedProperty(propName);
 }

 public PropertyDecorator(TypeModel model, Type forType, PropertyInfo property, IProtoSerializer tail) : base(tail)
 {
     Helpers.DebugAssert(forType != null);
     Helpers.DebugAssert(property != null);
     this.forType = forType;
     this.property = property;
     SanityCheck(model, property, tail, out readOptionsWriteValue, true, true);
     shadowSetter = GetShadowSetter(model, property);
 }

 public override Property Eval(Property[] args, PropertyInfo pInfo)
 {
     string propName = args[0].GetString();
     if (propName == null)
     {
         throw new PropertyException("Incorrect parameter to from-table-column function");
     }
     throw new PropertyException("from-table-column unimplemented!");
 }

 public override Property Eval(Property[] args, PropertyInfo pInfo)
 {
     string propName = args[0].GetString();
     if (propName == null)
     {
         throw new PropertyException("Incorrect parameter to from-nearest-specified-value function");
     }
     return pInfo.getPropertyList().GetNearestSpecifiedProperty(propName);
 }

 public override Property Eval(Property[] args, PropertyInfo pInfo)
 {
     string propName = args[0].GetString();
     if (propName == null)
     {
         throw new PropertyException("Missing property name.");
     }
     return pInfo.getPropertyList().GetProperty(propName);
 }

 public override Property Eval(Property[] args, PropertyInfo propInfo)
 {
     Numeric num = args[0].GetNumeric();
     if (num == null)
     {
         throw new PropertyException("Non numeric operand to abs function");
     }
     return new NumericProperty(num.abs());
 }

        public override Property Eval(Property[] args, PropertyInfo pInfo)
        {
            string propName = args[0].GetString();
            if (propName == null)
            {
                throw new PropertyException("Incorrect parameter to from-parent function");
            }

            return pInfo.getPropertyList().GetFromParentProperty(propName);
        }

 public override Property Eval(Property[] args, PropertyInfo pInfo)
 {
     Numeric n1 = args[0].GetNumeric();
     Numeric n2 = args[1].GetNumeric();
     if (n1 == null || n2 == null)
     {
         throw new PropertyException("Non numeric operands to max function");
     }
     return new NumericProperty(n1.max(n2));
 }