예제 #1
0
        public void Can_read_date_time_local()
        {
            var time         = DateTime.Now;
            var timeReturned = (DateTime?)null;

            Mock.Setup(x => x.Property).Returns(time);
            Mock.Setup(x => x.MethodParameter(It.IsAny <DateTime>()))
            .Callback(new Action <DateTime>(result =>
            {
                timeReturned = result;
            }));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0

                    DateTimeTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.MethodParameter(test.Property)
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.Verify(x => x.MethodParameter(It.IsAny <DateTime>()));
            Assert.NotNull(timeReturned);
            Assert.Equal(time.ToString("MM/dd/yyyy hh:mm:ss"), timeReturned.Value.ToString("MM/dd/yyyy hh:mm:ss"));
        }
예제 #2
0
        public void Can_call_correct_overload()
        {
            Mock.Setup(x => x.Overload());
            Mock.Setup(x => x.Overload(It.IsAny <string>()));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    ObjectTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.overload()
                        }
                    }
                ");

            Mock.Verify(x => x.Overload(), Times.Once);
            Mock.Verify(x => x.Overload(It.IsAny <string>()), Times.Never);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    ObjectTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.overload('test')
                        }
                    }
                ");

            Mock.Verify(x => x.Overload(), Times.Once);
            Mock.Verify(x => x.Overload(It.IsAny <string>()), Times.Once);
        }
예제 #3
0
        public void Can_send_non_function()
        {
            INetJsValue jsValue = null;

            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>()))
            .Callback(new Action <dynamic>(x =>
            {
                jsValue = x;
            }));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.method({})
                        }
                    }
                ");

            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>()), Times.Once);
            jsValue.Should().NotBeNull();
            jsValue.IsCallable.Should().BeFalse();
        }
예제 #4
0
        public void Can_read_write_property_nullable_with_value()
        {
            var value = DateTimeOffset.Now;

            // This trims some percision off of the milliseconds, makes the comparison accurate.
            value = new DateTimeOffset(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Offset);
            Mock.SetupGet(x => x.Nullable).Returns(value);
            Mock.SetupSet(x => x.Nullable = value);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    DateTimeOffsetTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var v = test.nullable
                            test.nullable = v
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Nullable, Times.Once);
            Mock.VerifySet(x => x.Nullable = value);
        }
예제 #5
0
        public void Can_pass_js_value_to_callback()
        {
            Mock.CallBase = true;
            Mock.Setup(x => x.MethodWithParameters("test1", 4));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var o = {
                                testProperty1: 'test1',
                                testProperty2: 4
                            }
                            test.callMethodWithJsValue(o,
                                function(passedIn) {
                                    test.methodWithParameters(passedIn.testProperty1, passedIn.testProperty2)
                                })
                        }
                    }
                ");

            Mock.Verify(x => x.CallMethodWithJsValue(It.IsAny <INetJsValue>(), It.IsAny <INetJsValue>()), Times.Once);
            Mock.Verify(x => x.MethodWithParameters("test1", 4), Times.Once);
        }
예제 #6
0
        public void Can_invoke_js_callback_with_net_instance()
        {
            var testObject = new JsValueTests.JsTestsQml.TestObject();

            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>()))
            .Callback(new Action <dynamic>(x =>
            {
                x(testObject);
            }));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.method(function(param1) {
                                param1.testMethod()
                                param1.testMethod()
                            })
                        }
                    }
                ");

            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>()), Times.Once);
            testObject.CalledCount.Should().Be(2);
        }
예제 #7
0
        public void Can_invoke_js_callback_with_parameters()
        {
            object result = null;

            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>()))
            .Callback(new Action <dynamic>(x =>
            {
                result = x("test1", 4);
            }));
            Mock.Setup(x => x.MethodWithParameters("test1", 4));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.method(function(param1, param2) {
                                test.methodWithParameters(param1, param2)
                            })
                        }
                    }
                ");

            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>()), Times.Once);
            Mock.Verify(x => x.MethodWithParameters("test1", 4), Times.Once);
            result.Should().BeNull();
        }
예제 #8
0
        protected void RunQmlTest(string instanceId, string componentOnCompletedCode, bool runEvents = false, bool failOnQmlWarnings = true)
        {
            var result = NetTestHelper.RunQml(
                qmlApplicationEngine,
                string.Format(
                    @"
                    import QtQuick 2.0
                    import tests 1.0
                    {0} {{
                        id: {1}
                        property var testQObject: null
                        function runTest() {{
                            {2}
                        }}
                    }}
                    ",
                    typeof(TTypeToRegister).Name,
                    instanceId,
                    componentOnCompletedCode),
                runEvents,
                failOnQmlWarnings);

            if (result == false)
            {
                throw new Exception($"Couldn't execute qml: {componentOnCompletedCode}");
            }
        }
예제 #9
0
        public void Can_read_date_time_utc()
        {
            var time         = DateTime.UtcNow;
            var timeReturned = (DateTime?)null;

            Mock.Setup(x => x.Property).Returns(time);
            Mock.Setup(x => x.MethodParameter(It.IsAny <DateTime>()))
            .Callback(new Action <DateTime>(result =>
            {
                timeReturned = result;
            }));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0

                    DateTimeTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.MethodParameter(test.Property)
                        }
                    }
                ");

            // NOTE: When qml handles dates, it always uses local time, so that is what we get back.
            // I'd like to get what I passed in, but there is no way to tell if original
            // DateTime value was UTC or not.
            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.Verify(x => x.MethodParameter(It.IsAny <DateTime>()));
            Assert.NotNull(timeReturned);
            Assert.Equal(time.ToUniversalTime().ToString("MM/dd/yyyy hh:mm:ss"), timeReturned.Value.ToUniversalTime().ToString("MM/dd/yyyy hh:mm:ss"));
        }
예제 #10
0
        public void Can_await_on_task_with_result()
        {
            var oldContext = SynchronizationContext.Current;

            SynchronizationContext.SetSynchronizationContext(new NoAsyncSynchronizationContext());

            try
            {
                Mock.Setup(x => x.TestAsync()).Returns(Task.FromResult("testt"));
                Mock.Setup(x => x.TestMethodWithArg("testt"));

                NetTestHelper.RunQml(qmlApplicationEngine,
                                     @"
                    import QtQuick 2.0
                    import tests 1.0
                    AwaitTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var task = test.testAsync()
                            Net.await(task, function(result) {
                                test.testMethodWithArg(result)
                            })
                        }
                    }
                ");

                Mock.Verify(x => x.TestMethodWithArg("testt"), Times.Once);
            }
            finally
            {
                SynchronizationContext.SetSynchronizationContext(oldContext);
            }
        }
예제 #11
0
 public void GlobalSetup()
 {
     _guiApplication       = new QGuiApplication(new[] { "-platform", "offscreen" });
     _qmlApplicationEngine = new QQmlApplicationEngine();
     NetTestHelper.RunQml(
         _qmlApplicationEngine,
         @"
                 import QtQuick 2.0
                 import tests 1.0
                 Item {{
                 }}");
     _qObject = Qt.BuildQObject("TestQObject*");
 }
예제 #12
0
        public void Can_set_properties()
        {
            var     testObject = new JsValueTests.JsTestsQml.TestObject();
            dynamic result     = null;

            Mock.Setup(x => x.GetTestObject()).Returns(testObject);
            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>(), It.IsAny <INetJsValue>()))
            .Callback(new Action <dynamic, dynamic>((source, destination) =>
            {
                destination.dest1 = source.source1;
                destination.dest2 = source.source2;
                destination.dest3 = source.source3;
                destination.dest4 = source.source4;
            }));
            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>()))
            .Callback(new Action <dynamic>(value => { result = value; }));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var netObject = test.getTestObject()
                            var source = {
                                source1: 123,
                                source2: 'value',
                                source3: netObject,
                                source4: {
                                }
                            }
                            var destination = {
                            }
                            test.method(source, destination)
                            test.method(destination)
                        }
                    }
                ");

            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>()), Times.Exactly(1));
            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>(), It.IsAny <INetJsValue>()), Times.Exactly(1));
            Mock.Verify(x => x.GetTestObject(), Times.Exactly(1));
            ((object)result).Should().NotBeNull();
            ((int)result.dest1).Should().Be(123);
            ((string)result.dest2).Should().Be("value");
            ((object)result.dest3).Should().BeSameAs(testObject);
            ((object)result.dest4).Should().BeAssignableTo <INetJsValue>();
        }
예제 #13
0
        public void Can_get_return_value_from_js_function()
        {
            var testObject = new JsTestsQml.TestObject();
            var results    = new List <object>();

            Mock.Setup(x => x.GetTestObject()).Returns(testObject);
            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>())).Callback(new Action <dynamic>(jsValue =>
            {
                results.Add((object)jsValue());
            }));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var jsObject = {
                            }
                            test.method(function() {
                                return 'test'
                            })
                            test.method(function() {
                                return 32
                            })
                            test.method(function() {
                                return jsObject
                            })
                            test.method(function() {
                                return function() {}
                            })
                            var netObject = test.getTestObject()
                            test.method(function() {
                                return netObject
                            })
                        }
                    }
                ");

            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>()), Times.Exactly(5));
            Mock.Verify(x => x.GetTestObject(), Times.Once);
            results.Should().HaveCount(5);
            results[0].Should().Be("test");
            results[1].Should().Be(32);
            results[2].Should().BeAssignableTo <INetJsValue>().And.Subject.As <INetJsValue>().IsCallable.Should().BeFalse();
            results[3].Should().BeAssignableTo <INetJsValue>().And.Subject.As <INetJsValue>().IsCallable.Should().BeTrue();
            results[4].Should().BeSameAs(testObject);
        }
예제 #14
0
        public void Can_register_singleton()
        {
            NetTestHelper.RunQml(
                qmlApplicationEngine,
                @"
                import QtQuick 2.0
                import tests 1.0
                Item {
                    id: test
                    Component.onCompleted: function() {
                        SingletonTestObject.property = ""test""
                    }
                }");

            Mock.VerifySet(x => x.Property = "test", Times.Once);
        }
예제 #15
0
        public void Can_call_method_with_parameter()
        {
            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    IntTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.methodParameter(3)
                        }
                    }
                ");

            Mock.Verify(x => x.MethodParameter(It.Is <int>(y => y == 3)), Times.Once);
        }
예제 #16
0
        public void Can_write_property_false()
        {
            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    BoolTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.property = false
                        }
                    }
                ");

            Mock.VerifySet(x => x.Property = false, Times.Once);
        }
예제 #17
0
        public void Can_set_method_parameter()
        {
            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    CharTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.methodParameter(""Ώ"")
                        }
                    }
                ");

            Mock.Verify(x => x.MethodParameter(It.IsIn('Ώ')), Times.Once);
        }
예제 #18
0
 protected void RunQmlTest(string instanceId, string componentOnCompletedCode)
 {
     NetTestHelper.RunQml(qmlApplicationEngine,
                          string.Format(@"
         import QtQuick 2.0
         import tests 1.0
         {0} {{
             id: {1}
             Component.onCompleted: function() {{
                 {2}
             }}
         }}
     ",
                                        typeof(TTypeToRegister).Name,
                                        instanceId,
                                        componentOnCompletedCode));
 }
예제 #19
0
        public void Can_call_method_with_return()
        {
            Mock.Setup(x => x.MethodReturn()).Returns(int.MaxValue);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    IntTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.methodParameter(test.methodReturn())
                        }
                    }
                ");

            Mock.Verify(x => x.MethodParameter(It.Is <int>(y => y == int.MaxValue)), Times.Once);
        }
예제 #20
0
        public void Can_use_as_return_type()
        {
            Mock.Setup(x => x.MethodReturn()).Returns('Ώ');

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    CharTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.methodParameter(test.methodReturn())
                        }
                    }
                ");

            Mock.Verify(x => x.MethodParameter(It.IsIn('Ώ')), Times.Once);
        }
예제 #21
0
        public void Can_get_items_from_list_model()
        {
            var list = new List <TestNetObject>();

            list.Add(new TestNetObject());
            list.Add(new TestNetObject());
            list.Add(new TestNetObject());
            var result = new List <TestNetObject>();

            Mock.Setup(x => x.GetNetObjectList()).Returns(list);
            Mock.Setup(x => x.Test(It.IsAny <object>())).Callback(new Action <object>(o => result.Add((TestNetObject)o)));

            NetTestHelper.RunQml(
                qmlApplicationEngine,
                @"
                    import QtQuick 2.0
                    import tests 1.0
                    Item {
                        ListModelTestsQml {
                            id: test
                            Component.onCompleted: function() {
                                var list = test.getNetObjectList()
                                var listModel = Net.toListModel(list)
                                rep.model = listModel
                            }
                        }
                        Repeater {
                            id: rep
                            Item {
                                Component.onCompleted: {
                                    test.test(modelData)
                                }
                            }
                        }
                    }
                ");

            Mock.Verify(x => x.GetNetObjectList(), Times.Once);
            Mock.Verify(x => x.Test(It.IsAny <object>()), Times.Exactly(3));
            list.Count.Should().Be(result.Count);
            list[0].Prop.Should().Be(result[0].Prop);
            list[1].Prop.Should().Be(result[1].Prop);
            list[2].Prop.Should().Be(result[2].Prop);
        }
예제 #22
0
        public void Can_read_write_int_max_value()
        {
            Mock.Setup(x => x.Property).Returns(int.MaxValue);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    IntTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.property = test.property
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.VerifySet(x => x.Property = int.MaxValue, Times.Once);
        }
예제 #23
0
        public void Can_read_write_value_unicode()
        {
            Mock.Setup(x => x.Property).Returns("test Ώ value");

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    StringTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.property = test.property
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.VerifySet(x => x.Property = "test Ώ value", Times.Once);
        }
예제 #24
0
        public void Can_read_write_char_null()
        {
            Mock.Setup(x => x.Property).Returns((char)0);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    CharTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.property = test.property
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.VerifySet(x => x.Property = (char)0, Times.Once);
        }
예제 #25
0
        public void Can_read_property_true()
        {
            Mock.Setup(x => x.Property).Returns(true);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    BoolTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.methodParameter(test.property)
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.Verify(x => x.MethodParameter(It.Is <bool>(y => y)));
        }
예제 #26
0
        public void Can_read_nullable_char_with_value()
        {
            Mock.Setup(x => x.Nullable).Returns('t');
            Mock.Setup(x => x.MethodParameterNullable(It.Is <char>(y => y == 't')));

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    CharTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.methodParameterNullable(test.nullable)
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Nullable, Times.Once);
            Mock.Verify(x => x.MethodParameterNullable(It.Is <char?>(y => y == 't')), Times.Once);
        }
예제 #27
0
        public void Can_read_write_property_nullable_without_value()
        {
            Mock.SetupGet(x => x.Nullable).Returns((DateTimeOffset?)null);
            Mock.SetupSet(x => x.Nullable = null);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    DateTimeOffsetTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var v = test.nullable
                            test.nullable = v
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Nullable, Times.Once);
            Mock.VerifySet(x => x.Nullable = null);
        }
예제 #28
0
        public void Can_read_write_property()
        {
            var value = DateTime.Now;

            Mock.SetupGet(x => x.Property).Returns(value);
            Mock.SetupSet(x => x.Property = value);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                import QtQuick 2.0
                import tests 1.0
                DateTimeTestsQml {
                    id: test
                    Component.onCompleted: function() {
                        test.property = test.property
                    }
                }
            ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.VerifySet(x => x.Property = value, Times.Once);
        }
예제 #29
0
        public void Can_read_properties_from_js_object()
        {
            var     testObject = new JsValueTests.JsTestsQml.TestObject();
            dynamic result     = null;

            Mock.Setup(x => x.Method(It.IsAny <INetJsValue>())).Callback(new Action <dynamic>(jsValue =>
            {
                result = jsValue;
            }));
            Mock.Setup(x => x.GetTestObject()).Returns(testObject);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0
                    JsTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            var netObject = test.getTestObject()
                            test.method({
                                test1: 34,
                                test2: 'test3',
                                test3: netObject,
                                test4: {
                                    test5: 'test5'
                                }
                            })
                        }
                    }
                ");

            Mock.Verify(x => x.Method(It.IsAny <INetJsValue>()), Times.Exactly(1));
            Mock.Verify(x => x.GetTestObject(), Times.Exactly(1));
            ((object)result.nonExistant).Should().BeNull();
            ((int)result.test1).Should().Be(34);
            ((string)result.test2).Should().Be("test3");
            ((object)result.test3).Should().BeSameAs(testObject);
            ((string)result.test4.test5).Should().Be("test5");
        }
예제 #30
0
        public void Can_read_write_char_unicode()
        {
            Mock.Setup(x => x.Property).Returns('Ώ');

            Console.WriteLine("char.MaxValue = " + (int)char.MaxValue);

            NetTestHelper.RunQml(qmlApplicationEngine,
                                 @"
                    import QtQuick 2.0
                    import tests 1.0

                    CharTestsQml {
                        id: test
                        Component.onCompleted: function() {
                            test.Property = test.Property
                        }
                    }
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.VerifySet(x => x.Property = 'Ώ', Times.Once);
        }