qml 0.0.7 → 1.0.0

data/ext/qml/lib/libqmlbind/test/fixtures/emptyhandlers.cpp

@@ -0,0 +1,36 @@
+#include "emptyhandlers.h"
+
+qmlbind_backref newObject(qmlbind_backref, qmlbind_signal_emitter)
+{
+    return nullptr;
+}
+
+qmlbind_value invokeMethod(qmlbind_engine, qmlbind_backref, const char *, int, qmlbind_value *)
+{
+    return qmlbind_value_new_undefined();
+}
+
+qmlbind_value invokeGetter(qmlbind_engine, qmlbind_backref, const char *)
+{
+    return qmlbind_value_new_undefined();
+}
+
+void invokeSetter(qmlbind_engine, qmlbind_backref, const char *, qmlbind_value)
+{
+}
+
+void deleteObject(qmlbind_backref)
+{
+}
+
+qmlbind_interface_handlers emptyHandlers()
+{
+    qmlbind_interface_handlers handlers = {
+        .new_object = &newObject,
+        .call_method = &invokeMethod,
+        .set_property = &invokeSetter,
+        .get_property = &invokeGetter,
+        .delete_object = &deleteObject
+    };
+    return handlers;
+}

data/ext/qml/lib/libqmlbind/test/fixtures/emptyhandlers.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <qmlbind.h>
+
+qmlbind_interface_handlers emptyHandlers();
+

data/ext/qml/lib/libqmlbind/test/fixtures/test.qml

@@ -0,0 +1,5 @@
+import QtQuick 2.0
+
+QtObject {
+  property int foo: 123
+}

data/ext/qml/lib/libqmlbind/test/fixtures/testmodule/qmldir

@@ -0,0 +1,2 @@
+module testmodule
+Test 1.0 test.qml

data/ext/qml/lib/libqmlbind/test/fixtures/testmodule/test.qml

@@ -0,0 +1,5 @@
+import QtQuick 2.0
+
+QtObject {
+  property int foo: 456
+}

data/ext/qml/lib/libqmlbind/test/iterator_test.cpp

@@ -0,0 +1,37 @@
+#include "test_helper.h"
+#include <catch.hpp>
+#include <qmlbind.h>
+#include <QList>
+
+TEST_CASE("iterator")
+{
+    constexpr auto count = 10;
+
+    auto engine = qmlbind_engine_new();
+    auto object = qmlbind_engine_new_object(engine);
+
+    for (auto i = 0; i < 10; ++i) {
+        auto value = qmlbind_value_new_number(i);
+        qmlbind_value_set_property(object, std::to_string(i).data(), value);
+        qmlbind_value_release(value);
+    }
+
+    auto iterator = qmlbind_iterator_new(object);
+
+    for (auto i = 0; qmlbind_iterator_has_next(iterator); ++i) {
+        qmlbind_iterator_next(iterator);
+
+        qmlbind_iterator_get_key(iterator);
+        auto key = qmlbind_iterator_get_key(iterator);
+        auto value = qmlbind_iterator_get_value(iterator);
+        REQUIRE(std::string(qmlbind_string_get_chars(key)) == std::to_string(i));
+        REQUIRE(qmlbind_value_get_number(value) == i);
+
+        qmlbind_string_release(key);
+        qmlbind_value_release(value);
+    }
+
+    qmlbind_iterator_release(iterator);
+    qmlbind_value_release(object);
+    qmlbind_engine_release(engine);
+}

data/ext/qml/lib/libqmlbind/test/main.cpp

@@ -0,0 +1,11 @@
+#define CATCH_CONFIG_RUNNER
+#include <catch.hpp>
+#include <qmlbind.h>
+
+int main(int argc, char **argv)
+{
+    auto app = qmlbind_application_new(argc, argv);
+    auto result = Catch::Session().run();
+    qmlbind_application_release(app);
+    return result;
+}

data/ext/qml/lib/libqmlbind/test/plugin_test.cpp

@@ -0,0 +1,41 @@
+
+#include "test_helper.h"
+#include <qmlbind.h>
+
+TEST_CASE("plugin")
+{
+    auto engine = qmlbind_engine_new();
+
+    SECTION("get_instance")
+    {
+#ifdef Q_OS_MAC
+        auto path = "../testplugin/libtestplugin.dylib";
+#else
+        auto path = "../testplugin/libtestplugin.so";
+#endif
+        auto plugin = qmlbind_plugin_new(path);
+
+        auto instance = qmlbind_plugin_get_instance(plugin, engine);
+        auto test = qmlbind_value_get_property(instance, "test");
+        REQUIRE(qmlbind_value_get_number(test) == 12345);
+        qmlbind_value_release(test);
+        qmlbind_value_release(instance);
+
+        REQUIRE(qmlbind_plugin_get_error_string(plugin) == NULL);
+
+        qmlbind_plugin_release(plugin);
+    }
+
+    SECTION("get_error")
+    {
+        auto plugin = qmlbind_plugin_new("./wrong/path");
+
+        auto error = qmlbind_plugin_get_error_string(plugin);
+        REQUIRE(qmlbind_string_get_length(error) > 0);
+        qmlbind_string_release(error);
+
+        qmlbind_plugin_release(plugin);
+    }
+
+    qmlbind_engine_release(engine);
+}

data/ext/qml/lib/libqmlbind/test/test.pro

@@ -0,0 +1,26 @@
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+CONFIG += c++11
+
+SOURCES += \
+    api.c \
+    main.cpp \
+    engine_test.cpp \
+    value_test.cpp \
+    iterator_test.cpp \
+    component_test.cpp \
+    exporter_test.cpp \
+    application_test.cpp \
+    fixtures/emptyhandlers.cpp \
+    plugin_test.cpp
+
+QMAKE_CFLAGS += "-std=c89"
+
+LIBS += -L$$PWD/../qmlbind/ -lqmlbind
+INCLUDEPATH += $$PWD/../qmlbind/include $$PWD/lib/Catch/include
+DEPENDPATH += $$PWD/../qmlbind
+
+HEADERS += \
+    test_helper.h \
+    fixtures/emptyhandlers.h

data/ext/qml/lib/libqmlbind/test/test_helper.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <QByteArray>
+#include <QString>
+#include <ostream>
+#include <catch.hpp>
+
+#define DESCRIBE(what) SECTION(what)
+#define CONTEXT(what) SECTION(what)
+#define IT(what) SECTION(what)
+
+inline std::ostream &operator<<(std::ostream &stream, const QByteArray &ba)
+{
+    return stream << ba.data();
+}
+
+inline std::ostream &operator<<(std::ostream &stream, const QString &str)
+{
+    return stream << str.toUtf8();
+}

data/ext/qml/lib/libqmlbind/test/value_test.cpp

@@ -0,0 +1,252 @@
+#include <catch.hpp>
+#include <qmlbind.h>
+#include <array>
+#include <string.h>
+
+TEST_CASE("value")
+{
+    auto engine = qmlbind_engine_new();
+    auto global = qmlbind_engine_get_global_object(engine);
+
+    SECTION("clone")
+    {
+        auto value = qmlbind_value_new_number(3.14);
+        auto clone = qmlbind_value_clone(value);
+
+        REQUIRE(qmlbind_value_get_number(clone) == 3.14);
+
+        qmlbind_value_release(clone);
+        qmlbind_value_release(value);
+    }
+
+    SECTION("comparison")
+    {
+        auto one1 = qmlbind_value_new_number(1);
+        auto one2 = qmlbind_value_new_number(1);
+        auto strOne = qmlbind_value_new_string_cstr("1");
+
+        SECTION("is_equal")
+        {
+            REQUIRE(qmlbind_value_is_equal(one1, strOne));
+        }
+
+        SECTION("is_identical")
+        {
+            REQUIRE(!qmlbind_value_is_identical(one1, strOne));
+            REQUIRE(qmlbind_value_is_identical(one1, one2));
+        }
+
+        qmlbind_value_release(one1);
+        qmlbind_value_release(one2);
+        qmlbind_value_release(strOne);
+    }
+
+    SECTION("undefined")
+    {
+        auto value = qmlbind_value_new_undefined();
+        REQUIRE(qmlbind_value_is_undefined(value));
+        qmlbind_value_release(value);
+    }
+
+    SECTION("null")
+    {
+        auto value = qmlbind_value_new_null();
+        REQUIRE(qmlbind_value_is_null(value));
+        qmlbind_value_release(value);
+    }
+
+    SECTION("true")
+    {
+        auto value = qmlbind_value_new_boolean(true);
+        REQUIRE(qmlbind_value_is_boolean(value));
+        REQUIRE(qmlbind_value_get_boolean(value));
+        qmlbind_value_release(value);
+    }
+
+    SECTION("false")
+    {
+        auto value = qmlbind_value_new_boolean(false);
+        REQUIRE(qmlbind_value_is_boolean(value));
+        REQUIRE(!qmlbind_value_get_boolean(value));
+        qmlbind_value_release(value);
+    }
+
+    SECTION("number")
+    {
+        auto value = qmlbind_value_new_number(3.14);
+        REQUIRE(qmlbind_value_is_number(value));
+        REQUIRE(qmlbind_value_get_number(value) == 3.14);
+        qmlbind_value_release(value);
+    }
+
+    SECTION("string")
+    {
+        auto str = "hoge";
+        auto value = qmlbind_value_new_string(strlen(str), str);
+        auto result = qmlbind_value_get_string(value);
+
+        REQUIRE(qmlbind_value_is_string(value));
+        REQUIRE(std::string(qmlbind_string_get_chars(result)) == str);
+        REQUIRE(qmlbind_string_get_length(result) == strlen(str));
+
+        qmlbind_string_release(result);
+        qmlbind_value_release(value);
+    }
+
+    SECTION("object")
+    {
+        auto value = qmlbind_engine_new_object(engine);
+        REQUIRE(qmlbind_value_is_object(value));
+
+        auto prop = qmlbind_value_new_number(123);
+        qmlbind_value_set_property(value, "prop", prop);
+        qmlbind_value_release(prop);
+
+        prop = qmlbind_value_get_property(value, "prop");
+        REQUIRE(qmlbind_value_get_number(prop) == 123);
+        qmlbind_value_release(prop);
+
+        qmlbind_value_release(value);
+    }
+
+    SECTION("function")
+    {
+        auto parseInt = qmlbind_value_get_property(global, "parseInt");
+
+        REQUIRE(qmlbind_value_is_function(parseInt));
+
+        auto str = qmlbind_value_new_string_cstr("123");
+        auto parsed = qmlbind_value_call(parseInt, 1, &str);
+
+        REQUIRE(qmlbind_value_get_number(parsed) == 123);
+
+        qmlbind_value_release(parseInt);
+        qmlbind_value_release(str);
+        qmlbind_value_release(parsed);
+    }
+
+    SECTION("construtor")
+    {
+        auto arrayConstructor = qmlbind_value_get_property(global, "Array");
+        auto len = qmlbind_value_new_number(10);
+
+        auto array = qmlbind_value_call_constructor(arrayConstructor, 1, &len);
+        qmlbind_value_release(len);
+
+        REQUIRE(qmlbind_value_is_array(array));
+
+        len = qmlbind_value_get_property(array, "length");
+        REQUIRE(qmlbind_value_get_number(len) == 10);
+
+        qmlbind_value_release(array);
+        qmlbind_value_release(len);
+        qmlbind_value_release(arrayConstructor);
+    }
+
+    SECTION("array")
+    {
+        constexpr auto count = 10;
+
+        auto array = qmlbind_engine_new_array(engine, count);
+
+        for (auto i = 0; i < count; ++i) {
+            auto value =  qmlbind_value_new_number(i);
+            qmlbind_value_set_array_item(array, i, value);
+            qmlbind_value_release(value);
+        }
+
+        REQUIRE(qmlbind_value_is_array(array));
+
+        for (auto i = 0; i < count; ++i) {
+            auto value = qmlbind_value_get_array_item(array, i);
+            REQUIRE(qmlbind_value_get_number(value) == i);
+            qmlbind_value_release(value);
+        }
+
+        qmlbind_value_release(array);
+    }
+
+    SECTION("set / get prototype")
+    {
+        auto proto = qmlbind_engine_new_object(engine);
+
+        {
+            auto prop = qmlbind_value_new_number(123);
+            qmlbind_value_set_property(proto, "prop", prop);
+            qmlbind_value_release(prop);
+        }
+
+        auto obj = qmlbind_engine_new_object(engine);
+        qmlbind_value_set_prototype(obj, proto);
+
+        {
+            auto prop = qmlbind_value_get_property(obj, "prop");
+            REQUIRE(qmlbind_value_get_number(prop) == 123);
+            qmlbind_value_release(prop);
+        }
+
+        auto gotProto = qmlbind_value_get_prototype(obj);
+        REQUIRE(qmlbind_value_is_identical(proto, gotProto));
+
+        qmlbind_value_release(obj);
+        qmlbind_value_release(proto);
+        qmlbind_value_release(gotProto);
+    }
+
+    SECTION("property manipulation")
+    {
+        auto proto = qmlbind_engine_new_object(engine);
+
+        {
+            auto prop = qmlbind_value_new_number(123);
+            qmlbind_value_set_property(proto, "inherited", prop);
+            qmlbind_value_release(prop);
+        }
+
+        auto obj = qmlbind_engine_new_object(engine);
+        qmlbind_value_set_prototype(obj, proto);
+
+        {
+            auto prop = qmlbind_value_new_number(456);
+            qmlbind_value_set_property(obj, "own", prop);
+            qmlbind_value_set_property(obj, "456", prop);
+            qmlbind_value_release(prop);
+        }
+
+        SECTION("#has_own_property")
+        {
+            REQUIRE(qmlbind_value_has_own_property(obj, "own"));
+            REQUIRE(!qmlbind_value_has_own_property(obj, "inherited"));
+        }
+
+        SECTION("#has_property")
+        {
+            REQUIRE(qmlbind_value_has_property(obj, "own"));
+            REQUIRE(qmlbind_value_has_property(obj, "inherited"));
+        }
+
+        SECTION("#has_key")
+        {
+            REQUIRE(qmlbind_value_has_index(obj, 456));
+        }
+
+        SECTION("#delete_property")
+        {
+            REQUIRE(qmlbind_value_delete_property(obj, "own"));
+            REQUIRE(!qmlbind_value_has_property(obj, "own"));
+        }
+
+        qmlbind_value_release(obj);
+        qmlbind_value_release(proto);
+    }
+
+    SECTION("error")
+    {
+        auto value = qmlbind_engine_eval(engine, "throw new Error('hoge')", "file", 1);
+        REQUIRE(qmlbind_value_is_error(value));
+        qmlbind_value_release(value);
+    }
+
+    qmlbind_value_release(global);
+    qmlbind_engine_release(engine);
+}