From e361d4443a0521c0820a0c73ad550602660466a3 Mon Sep 17 00:00:00 2001
From: Dustin Spicuzza <dustin@virtualroadside.com>
Date: Thu, 31 Dec 2020 00:40:42 -0500
Subject: [PATCH] Add additional template specialization tests

---
 tests/test_fn.py       |  67 +++++++++++++++++
 tests/test_template.py | 165 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 232 insertions(+)

diff --git a/tests/test_fn.py b/tests/test_fn.py
index 5c09cb9..9c3ad56 100644
--- a/tests/test_fn.py
+++ b/tests/test_fn.py
@@ -4,6 +4,7 @@ from cxxheaderparser.types import (
     Array,
     AutoSpecifier,
     Function,
+    FunctionType,
     FundamentalSpecifier,
     NameSpecifier,
     PQName,
@@ -518,3 +519,69 @@ def test_fn_with_impl():
             ]
         )
     )
+
+
+def test_fn_return_std_function():
+    content = """
+      std::function<void(int)> fn();
+    """
+    data1 = parse_string(content, cleandoc=True)
+
+    content = """
+      std::function<void((int))> fn();
+    """
+    data2 = parse_string(content, cleandoc=True)
+
+    expected = ParsedData(
+        namespace=NamespaceScope(
+            functions=[
+                Function(
+                    return_type=Type(
+                        typename=PQName(
+                            segments=[
+                                NameSpecifier(name="std"),
+                                NameSpecifier(
+                                    name="function",
+                                    specialization=TemplateSpecialization(
+                                        args=[
+                                            TemplateArgument(
+                                                arg=FunctionType(
+                                                    return_type=Type(
+                                                        typename=PQName(
+                                                            segments=[
+                                                                FundamentalSpecifier(
+                                                                    name="void"
+                                                                )
+                                                            ]
+                                                        )
+                                                    ),
+                                                    parameters=[
+                                                        Parameter(
+                                                            type=Type(
+                                                                typename=PQName(
+                                                                    segments=[
+                                                                        FundamentalSpecifier(
+                                                                            name="int"
+                                                                        )
+                                                                    ]
+                                                                )
+                                                            )
+                                                        )
+                                                    ],
+                                                )
+                                            )
+                                        ]
+                                    ),
+                                ),
+                            ]
+                        )
+                    ),
+                    name=PQName(segments=[NameSpecifier(name="fn")]),
+                    parameters=[],
+                )
+            ]
+        )
+    )
+
+    assert data1 == expected
+    assert data2 == expected
diff --git a/tests/test_template.py b/tests/test_template.py
index 0189b13..e0eb5e1 100644
--- a/tests/test_template.py
+++ b/tests/test_template.py
@@ -1649,3 +1649,168 @@ def test_template_many_packs():
             ]
         )
     )
+
+
+def test_template_specialized_fn_typename():
+    content = """
+      // clang-format off
+      struct T{};
+      
+      template <typename T>
+      class C {
+        template<>
+        void foo<typename ::T>();
+      }; 
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="T")], classkey="struct"
+                        )
+                    )
+                ),
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="C")], classkey="class"
+                        ),
+                        template=TemplateDecl(
+                            params=[TemplateTypeParam(typekey="typename", name="T")]
+                        ),
+                    ),
+                    methods=[
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(
+                                segments=[
+                                    NameSpecifier(
+                                        name="foo",
+                                        specialization=TemplateSpecialization(
+                                            args=[
+                                                TemplateArgument(
+                                                    arg=Type(
+                                                        typename=PQName(
+                                                            segments=[
+                                                                NameSpecifier(name=""),
+                                                                NameSpecifier(name="T"),
+                                                            ]
+                                                        )
+                                                    ),
+                                                    has_typename=True,
+                                                )
+                                            ]
+                                        ),
+                                    )
+                                ]
+                            ),
+                            parameters=[],
+                            template=TemplateDecl(),
+                            access="private",
+                        )
+                    ],
+                ),
+            ]
+        )
+    )
+
+
+def test_template_specialized_fn_typename_template():
+    content = """
+      // clang-format off
+      template <typename X>
+      struct T{};
+      
+      template <typename T>
+      class C {
+          template<>
+          void foo<typename ::template T<int>>();
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="T")], classkey="struct"
+                        ),
+                        template=TemplateDecl(
+                            params=[TemplateTypeParam(typekey="typename", name="X")]
+                        ),
+                    )
+                ),
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="C")], classkey="class"
+                        ),
+                        template=TemplateDecl(
+                            params=[TemplateTypeParam(typekey="typename", name="T")]
+                        ),
+                    ),
+                    methods=[
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(
+                                segments=[
+                                    NameSpecifier(
+                                        name="foo",
+                                        specialization=TemplateSpecialization(
+                                            args=[
+                                                TemplateArgument(
+                                                    arg=Type(
+                                                        typename=PQName(
+                                                            segments=[
+                                                                NameSpecifier(name=""),
+                                                                NameSpecifier(
+                                                                    name="T",
+                                                                    specialization=TemplateSpecialization(
+                                                                        args=[
+                                                                            TemplateArgument(
+                                                                                arg=Type(
+                                                                                    typename=PQName(
+                                                                                        segments=[
+                                                                                            FundamentalSpecifier(
+                                                                                                name="int"
+                                                                                            )
+                                                                                        ]
+                                                                                    )
+                                                                                )
+                                                                            )
+                                                                        ]
+                                                                    ),
+                                                                ),
+                                                            ]
+                                                        )
+                                                    ),
+                                                    has_typename=True,
+                                                )
+                                            ]
+                                        ),
+                                    )
+                                ]
+                            ),
+                            parameters=[],
+                            template=TemplateDecl(),
+                            access="private",
+                        )
+                    ],
+                ),
+            ]
+        )
+    )