File indexing completed on 2024-05-05 05:43:50

0001 from unittest import TestCase
0002 
0003 from doxyqml.lexer import Lexer
0004 from doxyqml.qmlclass import QmlClass
0005 from doxyqml import qmlparser
0006 
0007 
0008 class QmlParserTestCase(TestCase):
0009     def test(self):
0010         src = "Item { function foo() {} function bar() {} }"
0011         lexer = Lexer(src)
0012         lexer.tokenize()
0013         qmlclass = QmlClass("Foo")
0014         qmlparser.parse(lexer.tokens, qmlclass)
0015 
0016         self.assertEqual(qmlclass.base_name, "Item")
0017 
0018         functions = qmlclass.get_functions()
0019         self.assertEqual(len(functions), 2)
0020         self.assertEqual(functions[0].name, "foo")
0021         self.assertEqual(functions[1].name, "bar")
0022 
0023     def test_default_property(self):
0024         src = """Item {
0025             /// v1 doc
0026             default property int v1
0027             /// v2 doc
0028             property int v2
0029             }"""
0030         lexer = Lexer(src)
0031         lexer.tokenize()
0032         qmlclass = QmlClass("Foo")
0033         qmlparser.parse(lexer.tokens, qmlclass)
0034 
0035         properties = qmlclass.get_properties()
0036         self.assertEqual(len(properties), 2)
0037         self.assertEqual(properties[0].name, "v1")
0038         self.assertEqual(properties[0].type, "int")
0039         self.assertEqual(properties[0].doc, "/// v1 doc")
0040         self.assertTrue(properties[0].is_default)
0041 
0042         self.assertEqual(properties[1].name, "v2")
0043         self.assertEqual(properties[1].type, "int")
0044         self.assertEqual(properties[1].doc, "/// v2 doc")
0045         self.assertFalse(properties[1].is_default)
0046 
0047     def test_readonly_property(self):
0048         src = """Item {
0049             /// v1 doc
0050             readonly property int v1
0051             /// v2 doc
0052             property int v2
0053             }"""
0054         lexer = Lexer(src)
0055         lexer.tokenize()
0056         qmlclass = QmlClass("Foo")
0057         qmlparser.parse(lexer.tokens, qmlclass)
0058 
0059         properties = qmlclass.get_properties()
0060         self.assertEqual(len(properties), 2)
0061         self.assertEqual(properties[0].name, "v1")
0062         self.assertEqual(properties[0].type, "int")
0063         self.assertEqual(properties[0].doc, "/// v1 doc")
0064         self.assertTrue(properties[0].is_readonly)
0065 
0066         self.assertEqual(properties[1].name, "v2")
0067         self.assertEqual(properties[1].type, "int")
0068         self.assertEqual(properties[1].doc, "/// v2 doc")
0069         self.assertFalse(properties[1].is_readonly)
0070 
0071     def test_var_property(self):
0072         src = """Item {
0073             property var varProperty: { "key1": "value1", "key2": "value2" }
0074             }"""
0075 
0076         lexer = Lexer(src)
0077         lexer.tokenize()
0078         qmlclass = QmlClass("Foo")
0079         qmlparser.parse(lexer.tokens, qmlclass)
0080 
0081         properties = qmlclass.get_properties()
0082         self.assertEqual(len(properties), 1)
0083         self.assertEqual(properties[0].name, "varProperty")
0084         self.assertEqual(properties[0].type, "var")
0085 
0086     def test_function_property(self):
0087         src = """Item {
0088             property var fnProperty: function (arg1, arg2) { return arg1 + arg2; }
0089             }"""
0090 
0091         lexer = Lexer(src)
0092         lexer.tokenize()
0093         qmlclass = QmlClass("Foo")
0094         qmlparser.parse(lexer.tokens, qmlclass)
0095 
0096         properties = qmlclass.get_properties()
0097         self.assertEqual(len(properties), 1)
0098         self.assertEqual(properties[0].name, "fnProperty")
0099         self.assertEqual(properties[0].type, "var")
0100 
0101     def test_multiline_string(self):
0102         src = """Item {
0103             prop1: "A string that spans \\
0104             multiple lines"
0105             /// prop2 doc
0106             property string prop2: "bar"
0107             }"""
0108 
0109         lexer = Lexer(src)
0110         lexer.tokenize()
0111         qmlclass = QmlClass("Foo")
0112         qmlparser.parse(lexer.tokens, qmlclass)
0113 
0114         properties = qmlclass.get_properties()
0115         self.assertEqual(len(properties), 1)
0116         self.assertEqual(properties[0].name, "prop2")
0117         self.assertEqual(properties[0].type, "string")
0118         self.assertEqual(properties[0].doc, "/// prop2 doc")
0119 
0120     def test_normal_arguments(self):
0121         src = """Item {
0122                      function foo(arg1, arg2) {
0123                          return arg1 + arg2;
0124                      }
0125                  }"""
0126 
0127         lexer = Lexer(src)
0128         lexer.tokenize()
0129         qmlclass = QmlClass("Foo")
0130         qmlparser.parse(lexer.tokens, qmlclass)
0131 
0132         functions = qmlclass.get_functions()
0133         self.assertEqual(len(functions), 1)
0134         self.assertEqual(functions[0].name, "foo")
0135         self.assertEqual(functions[0].type, "void")
0136 
0137     def test_keyword_arguments(self):
0138         src = """Item {
0139                      function foo(propertyArgument, signalArgument) {
0140                          return propertyArgument + signalArgument;
0141                      }
0142                  }"""
0143 
0144         lexer = Lexer(src)
0145         lexer.tokenize()
0146         qmlclass = QmlClass("Foo")
0147         qmlparser.parse(lexer.tokens, qmlclass)
0148 
0149         functions = qmlclass.get_functions()
0150         self.assertEqual(len(functions), 1)
0151         self.assertEqual(functions[0].name, "foo")
0152         self.assertEqual(functions[0].type, "void")
0153 
0154     def test_signals(self):
0155         src = """Item {
0156                      signal userAdded(string username, int age)
0157                  }"""
0158 
0159         lexer = Lexer(src)
0160         lexer.tokenize()
0161         qmlclass = QmlClass("Foo")
0162         qmlparser.parse(lexer.tokens, qmlclass)
0163 
0164         signals = qmlclass.get_signals()
0165         self.assertEqual(len(signals), 1)
0166         signal = signals[0]
0167         self.assertEqual(signal.name, "userAdded")
0168 
0169         self.assertEqual(len(signal.args), 2)
0170         self.assertEqual(signal.args[0].name, "username")
0171         self.assertEqual(signal.args[0].type, "string")
0172         self.assertEqual(signal.args[1].name, "age")
0173         self.assertEqual(signal.args[1].type, "int")
0174 
0175     def test_functions(self):
0176         src = """Item {
0177                     function scale(aspect = 4.0 / 3.0) {}
0178                  }"""
0179         lexer = Lexer(src)
0180         lexer.tokenize()
0181         qmlclass = QmlClass("Foo")
0182         qmlparser.parse(lexer.tokens, qmlclass)
0183         functions = qmlclass.get_functions()
0184         self.assertEqual(len(functions), 1)
0185         self.assertEqual(functions[0].args[0].name, "aspect")
0186         self.assertEqual(functions[0].args[0].default_value, "4.0/3.0")