Added tests for properties.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>

src/Generator/Passes/GetterSetterToPropertyPass.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Text;
 using CppSharp.AST;
 
 namespace CppSharp.Passes
@@ -77,15 +79,19 @@ namespace CppSharp.Passes
                 foreach (var setter in group)
                 {
                     Class type = (Class) setter.Namespace;
-                    string afterSet = setter.Name.Substring(3);
+                    StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3));
+                    if (char.IsLower(setter.Name[0]))
+                        nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]);
+                    string afterSet = nameBuilder.ToString();
                     foreach (var getter in nonSetters.Where(m => m.Namespace == type))
                     {
-                        if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
+                        string name = GetPropertyName(getter.Name);
+                        if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
                             getter.ReturnType == setter.Parameters[0].QualifiedType &&
                             !type.Methods.Any(
                                 m =>
                                     m != getter &&
-                                    string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
+                                    string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
                         {
                             GenerateProperty(getter.Namespace, getter, readOnly ? null : setter);
                             goto next;
@@ -105,9 +111,7 @@ namespace CppSharp.Passes
             foreach (Method nonSetter in nonSetters)
             {
                 Class type = (Class) nonSetter.Namespace;
-                string name = nonSetter.Name;
-                if (GetFirstWord(name) == "get")
-                    name = name.Substring(3);
+                string name = GetPropertyName(nonSetter.Name);
                 Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name });
                 if (!type.IsInterface && baseVirtualProperty != null)
                 {
@@ -129,7 +133,7 @@ namespace CppSharp.Passes
                      p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl))
             {
                 Property property = new Property();
-                property.Name = getter.Name.Substring(GetFirstWord(getter.Name) == "get" ? 3 : 0);
+                property.Name = GetPropertyName(getter.Name);
                 property.Namespace = type;
                 property.QualifiedType = getter.ReturnType;
                 if (getter.IsOverride || (setter != null && setter.IsOverride))
@@ -138,7 +142,7 @@ namespace CppSharp.Passes
                     if (baseVirtualProperty.SetMethod == null)
                         setter = null;
                     foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0))
-                        method.Name = "Get" + method.Name;
+                        method.Name = "get" + method.Name;
                 }
                 property.GetMethod = getter;
                 property.SetMethod = setter;
@@ -155,6 +159,26 @@ namespace CppSharp.Passes
             }
         }
 
+        private static string GetPropertyName(string name)
+        {
+            if (GetFirstWord(name) == "get")
+            {
+                if (char.IsLower(name[0]))
+                {
+                    if (name.Length == 4)
+                    {
+                        return char.ToLowerInvariant(
+                            name[3]).ToString(CultureInfo.InvariantCulture);
+                    }
+                    return char.ToLowerInvariant(
+                        name[3]).ToString(CultureInfo.InvariantCulture) +
+                                    name.Substring(4);
+                }
+                return name.Substring(3);
+            }
+            return name;
+        }
+
 
         private void DistributeMethod(Method method)
         {
@@ -191,7 +215,8 @@ namespace CppSharp.Passes
                                     {
                                         char.ToLowerInvariant(name[0])
                                     };
-            firstVerb.AddRange(name.Skip(1).TakeWhile(char.IsLower));
+            firstVerb.AddRange(name.Skip(1).TakeWhile(
+                c => char.IsLower(c) || !char.IsLetterOrDigit(c)));
             return new string(firstVerb.ToArray());
         }
     }

tests/Basic/Basic.Tests.cs

@@ -112,7 +112,7 @@ public class BasicTests
     public void TestAbstractReturnType()
     {
         var returnsAbstractFoo = new ReturnsAbstractFoo();
-        var abstractFoo = returnsAbstractFoo.Foo;
+        var abstractFoo = returnsAbstractFoo.foo;
         Assert.AreEqual(abstractFoo.pureFunction, 5);
         Assert.AreEqual(abstractFoo.pureFunction1, 10);
         Assert.AreEqual(abstractFoo.pureFunction2, 15);

tests/CSharpTemp/CSharpTemp.Tests.cs

@@ -45,19 +45,34 @@ public class CSharpTempTests
     public void TestMultipleInheritance()
     {
         Baz baz = new Baz();
-        Assert.That(baz.method(), Is.EqualTo(1));
+        Assert.That(baz.method, Is.EqualTo(1));
         var bar = (IBar) baz;
-        Assert.That(bar.method(), Is.EqualTo(2));
+        Assert.That(bar.method, Is.EqualTo(2));
         Assert.That(baz[0], Is.EqualTo(50));
         bar[0] = new Foo { A = 1000 };
         Assert.That(bar[0].A, Is.EqualTo(1000));
-        Assert.That(baz.farAwayFunc(), Is.EqualTo(20));
+        Assert.That(baz.farAwayFunc, Is.EqualTo(20));
         Assert.That(baz.takesQux(baz), Is.EqualTo(20));
-        Assert.That(baz.returnQux().farAwayFunc(), Is.EqualTo(20));
+        Assert.That(baz.returnQux().farAwayFunc, Is.EqualTo(20));
         int cast = baz;
         Assert.That(cast, Is.EqualTo(500));
         var nested = new Baz.Nested();
         int nestedCast = nested;
         Assert.That(nestedCast, Is.EqualTo(300));
     }
+
+    [Test]
+    public void TestProperties()
+    {
+        var proprietor = new Proprietor();
+        proprietor.value = 20;
+        Assert.That(proprietor.value, Is.EqualTo(20));
+        proprietor.prop = 50;
+        Assert.That(proprietor.prop, Is.EqualTo(50));
+        var p = new P();
+        p.value = 20;
+        Assert.That(p.value, Is.EqualTo(30));
+        p.prop = 50;
+        Assert.That(p.prop, Is.EqualTo(150));
+    }
 }

tests/CSharpTemp/CSharpTemp.cpp

@@ -65,3 +65,33 @@ Baz::operator int() const
 {
     return 500;
 }
+
+int AbstractProprietor::getValue()
+{
+    return m_value;
+}
+
+void AbstractProprietor::setProp(long property)
+{
+    m_property = property;
+}
+
+void Proprietor::setValue(int value)
+{
+    m_value = value;
+}
+
+long Proprietor::prop()
+{
+    return m_property;
+}
+
+void P::setValue(int value)
+{
+    m_value = value + 10;
+}
+
+long P::prop()
+{
+    return m_property + 100;
+}

tests/CSharpTemp/CSharpTemp.h

@@ -63,3 +63,32 @@ struct QByteArrayDataPtr
 {
     QByteArrayData* ptr;
 };
+
+class DLL_API AbstractProprietor
+{
+public:
+    virtual int getValue();
+    virtual void setValue(int value) = 0;
+
+    virtual long prop() = 0;
+    virtual void setProp(long prop);
+
+protected:
+    int m_value;
+    long m_property;
+};
+
+class DLL_API Proprietor : public AbstractProprietor
+{
+public:
+    virtual void setValue(int value);
+
+    virtual long prop();
+};
+
+class DLL_API P : Proprietor
+{
+public:
+    virtual void setValue(int value);
+    virtual long prop();
+};