diff --git a/tests/test_class.py b/tests/test_class.py
index 599afb0..ed60f26 100644
--- a/tests/test_class.py
+++ b/tests/test_class.py
@@ -2998,3 +2998,217 @@ def test_class_mutable() -> None:
             ]
         )
     )
+
+
+def test_nested_class_access() -> None:
+    content = """
+      class Outer {
+          struct Inner {
+              void fn();
+          };
+
+          void ofn();
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="Outer")], classkey="class"
+                        )
+                    ),
+                    classes=[
+                        ClassScope(
+                            class_decl=ClassDecl(
+                                typename=PQName(
+                                    segments=[NameSpecifier(name="Inner")],
+                                    classkey="struct",
+                                ),
+                                access="private",
+                            ),
+                            methods=[
+                                Method(
+                                    return_type=Type(
+                                        typename=PQName(
+                                            segments=[FundamentalSpecifier(name="void")]
+                                        )
+                                    ),
+                                    name=PQName(segments=[NameSpecifier(name="fn")]),
+                                    parameters=[],
+                                    access="public",
+                                )
+                            ],
+                        )
+                    ],
+                    methods=[
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(segments=[NameSpecifier(name="ofn")]),
+                            parameters=[],
+                            access="private",
+                        )
+                    ],
+                )
+            ]
+        )
+    )
+
+
+def test_class_with_typedef() -> None:
+    content = """
+      template <class SomeType> class A {
+       public:
+        typedef B <SomeType> C;
+
+        A();
+
+       protected:
+        C aCInstance;
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="A")], classkey="class"
+                        ),
+                        template=TemplateDecl(
+                            params=[TemplateTypeParam(typekey="class", name="SomeType")]
+                        ),
+                    ),
+                    fields=[
+                        Field(
+                            access="protected",
+                            type=Type(
+                                typename=PQName(segments=[NameSpecifier(name="C")])
+                            ),
+                            name="aCInstance",
+                        )
+                    ],
+                    methods=[
+                        Method(
+                            return_type=None,
+                            name=PQName(segments=[NameSpecifier(name="A")]),
+                            parameters=[],
+                            access="public",
+                            constructor=True,
+                        )
+                    ],
+                    typedefs=[
+                        Typedef(
+                            type=Type(
+                                typename=PQName(
+                                    segments=[
+                                        NameSpecifier(
+                                            name="B",
+                                            specialization=TemplateSpecialization(
+                                                args=[
+                                                    TemplateArgument(
+                                                        arg=Type(
+                                                            typename=PQName(
+                                                                segments=[
+                                                                    NameSpecifier(
+                                                                        name="SomeType"
+                                                                    )
+                                                                ]
+                                                            )
+                                                        )
+                                                    )
+                                                ]
+                                            ),
+                                        )
+                                    ]
+                                )
+                            ),
+                            name="C",
+                            access="public",
+                        )
+                    ],
+                )
+            ]
+        )
+    )
+
+
+def test_class_ref_qualifiers() -> None:
+    content = """
+      struct X {
+        void fn0();
+        void fn1() &;
+        void fn2() &&;
+        void fn3() && = 0;
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="X")], classkey="struct"
+                        )
+                    ),
+                    methods=[
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(segments=[NameSpecifier(name="fn0")]),
+                            parameters=[],
+                            access="public",
+                        ),
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(segments=[NameSpecifier(name="fn1")]),
+                            parameters=[],
+                            access="public",
+                            ref_qualifier="&",
+                        ),
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(segments=[NameSpecifier(name="fn2")]),
+                            parameters=[],
+                            access="public",
+                            ref_qualifier="&&",
+                        ),
+                        Method(
+                            return_type=Type(
+                                typename=PQName(
+                                    segments=[FundamentalSpecifier(name="void")]
+                                )
+                            ),
+                            name=PQName(segments=[NameSpecifier(name="fn3")]),
+                            parameters=[],
+                            access="public",
+                            ref_qualifier="&&",
+                            pure_virtual=True,
+                        ),
+                    ],
+                )
+            ]
+        )
+    )
diff --git a/tests/test_using.py b/tests/test_using.py
index ca1d76e..06a355f 100644
--- a/tests/test_using.py
+++ b/tests/test_using.py
@@ -548,3 +548,171 @@ def test_using_many_things() -> None:
             },
         )
     )
+
+
+def test_using_template_in_class() -> None:
+    content = """
+      class X {
+        template <typename T>
+        using TT = U<T>;
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="X")], classkey="class"
+                        )
+                    ),
+                    using_alias=[
+                        UsingAlias(
+                            alias="TT",
+                            type=Type(
+                                typename=PQName(
+                                    segments=[
+                                        NameSpecifier(
+                                            name="U",
+                                            specialization=TemplateSpecialization(
+                                                args=[
+                                                    TemplateArgument(
+                                                        arg=Type(
+                                                            typename=PQName(
+                                                                segments=[
+                                                                    NameSpecifier(
+                                                                        name="T"
+                                                                    )
+                                                                ]
+                                                            )
+                                                        )
+                                                    )
+                                                ]
+                                            ),
+                                        )
+                                    ]
+                                )
+                            ),
+                            template=TemplateDecl(
+                                params=[TemplateTypeParam(typekey="typename", name="T")]
+                            ),
+                            access="private",
+                        )
+                    ],
+                )
+            ]
+        )
+    )
+
+
+def test_using_typename_in_class() -> None:
+    content = """
+      template <class D> class P {
+      using A = typename f::TP<D>::A;
+      public:
+        using State = typename f::TP<D>::S;
+        P(State st);
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="P")], classkey="class"
+                        ),
+                        template=TemplateDecl(
+                            params=[TemplateTypeParam(typekey="class", name="D")]
+                        ),
+                    ),
+                    methods=[
+                        Method(
+                            return_type=None,
+                            name=PQName(segments=[NameSpecifier(name="P")]),
+                            parameters=[
+                                Parameter(
+                                    type=Type(
+                                        typename=PQName(
+                                            segments=[NameSpecifier(name="State")]
+                                        )
+                                    ),
+                                    name="st",
+                                )
+                            ],
+                            access="public",
+                            constructor=True,
+                        )
+                    ],
+                    using_alias=[
+                        UsingAlias(
+                            alias="A",
+                            type=Type(
+                                typename=PQName(
+                                    segments=[
+                                        NameSpecifier(name="f"),
+                                        NameSpecifier(
+                                            name="TP",
+                                            specialization=TemplateSpecialization(
+                                                args=[
+                                                    TemplateArgument(
+                                                        arg=Type(
+                                                            typename=PQName(
+                                                                segments=[
+                                                                    NameSpecifier(
+                                                                        name="D"
+                                                                    )
+                                                                ]
+                                                            )
+                                                        )
+                                                    )
+                                                ]
+                                            ),
+                                        ),
+                                        NameSpecifier(name="A"),
+                                    ],
+                                    has_typename=True,
+                                )
+                            ),
+                            access="private",
+                        ),
+                        UsingAlias(
+                            alias="State",
+                            type=Type(
+                                typename=PQName(
+                                    segments=[
+                                        NameSpecifier(name="f"),
+                                        NameSpecifier(
+                                            name="TP",
+                                            specialization=TemplateSpecialization(
+                                                args=[
+                                                    TemplateArgument(
+                                                        arg=Type(
+                                                            typename=PQName(
+                                                                segments=[
+                                                                    NameSpecifier(
+                                                                        name="D"
+                                                                    )
+                                                                ]
+                                                            )
+                                                        )
+                                                    )
+                                                ]
+                                            ),
+                                        ),
+                                        NameSpecifier(name="S"),
+                                    ],
+                                    has_typename=True,
+                                )
+                            ),
+                            access="public",
+                        ),
+                    ],
+                )
+            ]
+        )
+    )