diff --git a/common-rust/src/types.rs b/common-rust/src/types.rs
index c416ff5..e3d9760 100644
--- a/common-rust/src/types.rs
+++ b/common-rust/src/types.rs
@@ -57,6 +57,7 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
 pub enum Variant {
     None,
     Bool(bool),
+    Int(c_int),
     String(String),
     ByteArray(Vec<u8>),
 }
@@ -79,6 +80,7 @@ impl From<String> for Variant {
 enum VariantType {
     Invalid = 0,
     Bool = 1,
+    Int = 2,
     String = 10,
     ByteArray = 12,
 }
@@ -100,6 +102,9 @@ impl<'a> QVariant<'a> {
             VariantType::Bool => {
                 Variant::Bool(self.value != 0)
             },
+            VariantType::Int => {
+                Variant::Int(self.value)
+            },
             VariantType::String => {
                 let data = unsafe {
                     let d = self.data as *const uint16_t;
@@ -137,6 +142,14 @@ impl<'a> From<&'a Variant> for QVariant<'a> {
                     phantom: PhantomData,
                 }
             }
+            Variant::Int(v) => {
+                QVariant {
+                    data: null(),
+                    value: v,
+                    type_: VariantType::Int,
+                    phantom: PhantomData,
+                }
+            }
             Variant::String(ref v) => {
                 QVariant {
                     data: v.as_ptr(),
diff --git a/rust_qt_binding_generator/rust_qt_binding_generator.cpp b/rust_qt_binding_generator/rust_qt_binding_generator.cpp
index a775101..69a2699 100644
--- a/rust_qt_binding_generator/rust_qt_binding_generator.cpp
+++ b/rust_qt_binding_generator/rust_qt_binding_generator.cpp
@@ -526,6 +526,7 @@ namespace {
         switch (v.type) {
             case QVariant::String: return QString::fromUtf8(static_cast<const char*>(v.data), v.value);
             case QVariant::Bool: return QVariant((bool)v.value);
+            case QVariant::Int: return QVariant(v.value);
             case QVariant::ByteArray: return QVariant(QByteArray(v.data, v.value));
             default:;
         }
diff --git a/src/tmp.cpp b/src/tmp.cpp
index 2ab363e..34d5fb7 100644
--- a/src/tmp.cpp
+++ b/src/tmp.cpp
@@ -45,6 +45,7 @@ namespace {
         switch (v.type) {
             case QVariant::String: return QString::fromUtf8(static_cast<const char*>(v.data), v.value);
             case QVariant::Bool: return QVariant((bool)v.value);
+            case QVariant::Int: return QVariant(v.value);
             case QVariant::ByteArray: return QVariant(QByteArray(v.data, v.value));
             default:;
         }
diff --git a/tests/rust_object/src/types.rs b/tests/rust_object/src/types.rs
index c416ff5..e3d9760 100644
--- a/tests/rust_object/src/types.rs
+++ b/tests/rust_object/src/types.rs
@@ -57,6 +57,7 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
 pub enum Variant {
     None,
     Bool(bool),
+    Int(c_int),
     String(String),
     ByteArray(Vec<u8>),
 }
@@ -79,6 +80,7 @@ impl From<String> for Variant {
 enum VariantType {
     Invalid = 0,
     Bool = 1,
+    Int = 2,
     String = 10,
     ByteArray = 12,
 }
@@ -100,6 +102,9 @@ impl<'a> QVariant<'a> {
             VariantType::Bool => {
                 Variant::Bool(self.value != 0)
             },
+            VariantType::Int => {
+                Variant::Int(self.value)
+            },
             VariantType::String => {
                 let data = unsafe {
                     let d = self.data as *const uint16_t;
@@ -137,6 +142,14 @@ impl<'a> From<&'a Variant> for QVariant<'a> {
                     phantom: PhantomData,
                 }
             }
+            Variant::Int(v) => {
+                QVariant {
+                    data: null(),
+                    value: v,
+                    type_: VariantType::Int,
+                    phantom: PhantomData,
+                }
+            }
             Variant::String(ref v) => {
                 QVariant {
                     data: v.as_ptr(),
diff --git a/tests/rust_object_types/src/types.rs b/tests/rust_object_types/src/types.rs
index c416ff5..e3d9760 100644
--- a/tests/rust_object_types/src/types.rs
+++ b/tests/rust_object_types/src/types.rs
@@ -57,6 +57,7 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
 pub enum Variant {
     None,
     Bool(bool),
+    Int(c_int),
     String(String),
     ByteArray(Vec<u8>),
 }
@@ -79,6 +80,7 @@ impl From<String> for Variant {
 enum VariantType {
     Invalid = 0,
     Bool = 1,
+    Int = 2,
     String = 10,
     ByteArray = 12,
 }
@@ -100,6 +102,9 @@ impl<'a> QVariant<'a> {
             VariantType::Bool => {
                 Variant::Bool(self.value != 0)
             },
+            VariantType::Int => {
+                Variant::Int(self.value)
+            },
             VariantType::String => {
                 let data = unsafe {
                     let d = self.data as *const uint16_t;
@@ -137,6 +142,14 @@ impl<'a> From<&'a Variant> for QVariant<'a> {
                     phantom: PhantomData,
                 }
             }
+            Variant::Int(v) => {
+                QVariant {
+                    data: null(),
+                    value: v,
+                    type_: VariantType::Int,
+                    phantom: PhantomData,
+                }
+            }
             Variant::String(ref v) => {
                 QVariant {
                     data: v.as_ptr(),
diff --git a/tests/test_object_rust.cpp b/tests/test_object_rust.cpp
index 9589b43..af29823 100644
--- a/tests/test_object_rust.cpp
+++ b/tests/test_object_rust.cpp
@@ -45,6 +45,7 @@ namespace {
         switch (v.type) {
             case QVariant::String: return QString::fromUtf8(static_cast<const char*>(v.data), v.value);
             case QVariant::Bool: return QVariant((bool)v.value);
+            case QVariant::Int: return QVariant(v.value);
             case QVariant::ByteArray: return QVariant(QByteArray(v.data, v.value));
             default:;
         }
diff --git a/tests/test_object_types.cpp b/tests/test_object_types.cpp
index 37ef034..b7af760 100644
--- a/tests/test_object_types.cpp
+++ b/tests/test_object_types.cpp
@@ -1,6 +1,7 @@
 #include "test_object_types_rust.h"
 #include <QTest>
 #include <QSignalSpy>
+#include <QDebug>
 
 class TestRustObjectTypes : public QObject
 {
@@ -13,18 +14,19 @@ private slots:
 void TestRustObjectTypes::testSetter()
 {
     // GIVEN
-    Person person;
-    const QVariant userName;
-    QSignalSpy spy(&person, &Person::userNameChanged);
+    QFETCH(QVariant, value);
+    Object object;
+    QSignalSpy spy(&object, &Object::valueChanged);
 
     // WHEN
-    person.setUserName(userName);
+    object.setValue(value);
 
     // THEN
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
-    QCOMPARE(person.userName().type(), userName.type());
-    QCOMPARE(person.userName(), userName);
+    auto resultType = object.value().type();
+    QCOMPARE(resultType, value.type());
+    QCOMPARE(object.value(), value);
 }
 
 void TestRustObjectTypes::testSetter_data()
diff --git a/tests/test_object_types.json b/tests/test_object_types.json
index 7db52a9..9a71db9 100644
--- a/tests/test_object_types.json
+++ b/tests/test_object_types.json
@@ -6,10 +6,10 @@
         "implementationModule": "implementation"
     },
     "objects": [{
-        "name": "Person",
+        "name": "Object",
         "type": "Object",
         "properties": [{
-            "name": "userName",
+            "name": "value",
             "type": "QVariant",
             "write": true
         }]
diff --git a/tests/test_object_types_rust.cpp b/tests/test_object_types_rust.cpp
index 3376375..d56f5da 100644
--- a/tests/test_object_types_rust.cpp
+++ b/tests/test_object_types_rust.cpp
@@ -45,6 +45,7 @@ namespace {
         switch (v.type) {
             case QVariant::String: return QString::fromUtf8(static_cast<const char*>(v.data), v.value);
             case QVariant::Bool: return QVariant((bool)v.value);
+            case QVariant::Int: return QVariant(v.value);
             case QVariant::ByteArray: return QVariant(QByteArray(v.data, v.value));
             default:;
         }
@@ -109,25 +110,25 @@ void set_qvariant(QVariant* v, qvariant_t* val) {
 }
 
 extern "C" {
-    PersonInterface* person_new(Person*, void (*)(Person*));
-    void person_free(PersonInterface*);
-    void person_user_name_get(PersonInterface*, QVariant*, qvariant_set);
-    void person_user_name_set(void*, qvariant_t);
+    ObjectInterface* object_new(Object*, void (*)(Object*));
+    void object_free(ObjectInterface*);
+    void object_value_get(ObjectInterface*, QVariant*, qvariant_set);
+    void object_value_set(void*, qvariant_t);
 };
-Person::Person(QObject *parent):
+Object::Object(QObject *parent):
     QObject(parent),
-    d(person_new(this,
-        [](Person* o) { emit o->userNameChanged(); })) {}
+    d(object_new(this,
+        [](Object* o) { emit o->valueChanged(); })) {}
 
-Person::~Person() {
-    person_free(d);
+Object::~Object() {
+    object_free(d);
 }
-QVariant Person::userName() const
+QVariant Object::value() const
 {
     QVariant v;
-    person_user_name_get(d, &v, set_qvariant);
+    object_value_get(d, &v, set_qvariant);
     return v;
 }
-void Person::setUserName(const QVariant& v) {
-    variant(v, d, person_user_name_set);
+void Object::setValue(const QVariant& v) {
+    variant(v, d, object_value_set);
 }
diff --git a/tests/test_object_types_rust.h b/tests/test_object_types_rust.h
index 1eb64da..6d552c3 100644
--- a/tests/test_object_types_rust.h
+++ b/tests/test_object_types_rust.h
@@ -6,20 +6,20 @@
 #include <QVariant>
 #include <QAbstractItemModel>
 
-class PersonInterface;
-class Person : public QObject
+class ObjectInterface;
+class Object : public QObject
 {
     Q_OBJECT
-    PersonInterface * const d;
-    Q_PROPERTY(QVariant userName READ userName WRITE setUserName NOTIFY userNameChanged FINAL)
+    ObjectInterface * const d;
+    Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged FINAL)
 public:
-    explicit Person(QObject *parent = nullptr);
-    ~Person();
-    QVariant userName() const;
-    void setUserName(const QVariant& v);
+    explicit Object(QObject *parent = nullptr);
+    ~Object();
+    QVariant value() const;
+    void setValue(const QVariant& v);
 signals:
-    void userNameChanged();
+    void valueChanged();
 private:
-    QVariant m_userName;
+    QVariant m_value;
 };
 #endif // TEST_OBJECT_TYPES_RUST_H