diff --git a/composer.json b/composer.json
index 87b34fe..33ba2f9 100644
--- a/composer.json
+++ b/composer.json
@@ -8,6 +8,9 @@
             "PhpStaticAnalysis\\Attributes\\": "src/"
         }
     },
+    "autoload-dev": {
+        "files": ["tests/AttributeHelper.php"]
+    },
     "authors": [
         {
             "name": "Carlos Granados",
diff --git a/tests/AssertIfFalseTest.php b/tests/AssertIfFalseTest.php
index f64e24f..5b3dbfc 100644
--- a/tests/AssertIfFalseTest.php
+++ b/tests/AssertIfFalseTest.php
@@ -115,26 +115,17 @@ private function getAsserts(string $functionName): array
     public static function getAssertsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getFunctionInstances($reflection, AssertIfFalse::class);
         $asserts = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === AssertIfFalse::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof AssertIfFalse);
-                $asserts = array_merge($asserts, $instance->params);
-            }
+
+        foreach ($instances['function'] as $instance) {
+            $asserts = array_merge($asserts, $instance->params);
         }
 
-        $parameters = $reflection->getParameters();
-        foreach ($parameters as $parameter) {
-            $attributes = $parameter->getAttributes();
-            foreach ($attributes as $attribute) {
-                if ($attribute->getName() === AssertIfFalse::class) {
-                    $instance = $attribute->newInstance();
-                    assert($instance instanceof AssertIfFalse);
-                    $argument = $instance->params[array_key_first($instance->params)];
-                    $asserts[$parameter->name] = $argument;
-                }
+        foreach ($instances['parameters'] as $name => $attrs) {
+            foreach ($attrs as $instance) {
+                $argument = $instance->params[array_key_first($instance->params)];
+                $asserts[$name] = $argument;
             }
         }
 
diff --git a/tests/AssertIfTrueTest.php b/tests/AssertIfTrueTest.php
index 9869243..5fc582e 100644
--- a/tests/AssertIfTrueTest.php
+++ b/tests/AssertIfTrueTest.php
@@ -115,26 +115,17 @@ private function getAsserts(string $functionName): array
     public static function getAssertsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getFunctionInstances($reflection, AssertIfTrue::class);
         $asserts = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === AssertIfTrue::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof AssertIfTrue);
-                $asserts = array_merge($asserts, $instance->params);
-            }
+
+        foreach ($instances['function'] as $instance) {
+            $asserts = array_merge($asserts, $instance->params);
         }
 
-        $parameters = $reflection->getParameters();
-        foreach ($parameters as $parameter) {
-            $attributes = $parameter->getAttributes();
-            foreach ($attributes as $attribute) {
-                if ($attribute->getName() === AssertIfTrue::class) {
-                    $instance = $attribute->newInstance();
-                    assert($instance instanceof AssertIfTrue);
-                    $argument = $instance->params[array_key_first($instance->params)];
-                    $asserts[$parameter->name] = $argument;
-                }
+        foreach ($instances['parameters'] as $name => $attrs) {
+            foreach ($attrs as $instance) {
+                $argument = $instance->params[array_key_first($instance->params)];
+                $asserts[$name] = $argument;
             }
         }
 
diff --git a/tests/AssertTest.php b/tests/AssertTest.php
index 44ce2c8..9b86f3d 100644
--- a/tests/AssertTest.php
+++ b/tests/AssertTest.php
@@ -104,26 +104,17 @@ private function getAsserts(string $functionName): array
     public static function getAssertsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getFunctionInstances($reflection, Assert::class);
         $asserts = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Assert::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Assert);
-                $asserts = array_merge($asserts, $instance->params);
-            }
+
+        foreach ($instances['function'] as $instance) {
+            $asserts = array_merge($asserts, $instance->params);
         }
 
-        $parameters = $reflection->getParameters();
-        foreach ($parameters as $parameter) {
-            $attributes = $parameter->getAttributes();
-            foreach ($attributes as $attribute) {
-                if ($attribute->getName() === Assert::class) {
-                    $instance = $attribute->newInstance();
-                    assert($instance instanceof Assert);
-                    $argument = $instance->params[array_key_first($instance->params)];
-                    $asserts[$parameter->name] = $argument;
-                }
+        foreach ($instances['parameters'] as $name => $attrs) {
+            foreach ($attrs as $instance) {
+                $argument = $instance->params[array_key_first($instance->params)];
+                $asserts[$name] = $argument;
             }
         }
 
diff --git a/tests/AttributeHelper.php b/tests/AttributeHelper.php
new file mode 100644
index 0000000..785fec1
--- /dev/null
+++ b/tests/AttributeHelper.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+
+final class AttributeHelper
+{
+    /**
+     * Return instances of an attribute on a reflector.
+     *
+     * @template T of object
+     * @param \ReflectionClass|\ReflectionFunction|\ReflectionMethod|\ReflectionParameter|\ReflectionProperty|\ReflectionClassConstant $reflector
+     * @param class-string<T> $attributeClass
+     * @return list<T>
+     */
+    public static function getInstances(\Reflector $reflector, string $attributeClass): array
+    {
+        return array_map(
+            static fn (\ReflectionAttribute $attribute) => $attribute->newInstance(),
+            $reflector->getAttributes($attributeClass)
+        );
+    }
+
+    /**
+     * Retrieve attribute instances from a function or method and its parameters.
+     *
+     * @template T of object
+     * @param \ReflectionFunction|\ReflectionMethod $reflector
+     * @param class-string<T> $attributeClass
+     * @return array{function: list<T>, parameters: array<string, list<T>>}
+     */
+    public static function getFunctionInstances(\ReflectionFunctionAbstract $reflector, string $attributeClass): array
+    {
+        $function = self::getInstances($reflector, $attributeClass);
+        $parameters = [];
+        foreach ($reflector->getParameters() as $parameter) {
+            $parameters[$parameter->name] = self::getInstances($parameter, $attributeClass);
+        }
+        return ['function' => $function, 'parameters' => $parameters];
+    }
+}
diff --git a/tests/DefineTypeTest.php b/tests/DefineTypeTest.php
index cee8c33..fc3ddef 100644
--- a/tests/DefineTypeTest.php
+++ b/tests/DefineTypeTest.php
@@ -27,14 +27,10 @@ public function testClassTypes(): void
     public static function getPropertiesFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, DefineType::class);
         $properties = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === DefineType::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof DefineType);
-                $properties = array_merge($properties, $instance->types);
-            }
+        foreach ($instances as $instance) {
+            $properties = array_merge($properties, $instance->types);
         }
 
         return $properties;
diff --git a/tests/DeprecatedTest.php b/tests/DeprecatedTest.php
index 7e4979e..e574ca6 100644
--- a/tests/DeprecatedTest.php
+++ b/tests/DeprecatedTest.php
@@ -78,16 +78,7 @@ private function getDeprecated(string $methodName): bool
     public static function getDeprecatedFromReflection(
         ReflectionMethod | ReflectionFunction | ReflectionClass | ReflectionProperty $reflection
     ): bool {
-        $attributes = $reflection->getAttributes();
-        $deprecated = false;
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Deprecated::class) {
-                $attribute->newInstance();
-                $deprecated = true;
-            }
-        }
-
-        return $deprecated;
+        return AttributeHelper::getInstances($reflection, Deprecated::class) !== [];
     }
 }
 
diff --git a/tests/ImmutableTest.php b/tests/ImmutableTest.php
index 2e24469..1d0ae0e 100644
--- a/tests/ImmutableTest.php
+++ b/tests/ImmutableTest.php
@@ -29,16 +29,7 @@ public function testInterfaceImmutable(): void
     public static function getImmutableFromReflection(
         ReflectionClass $reflection
     ): bool {
-        $attributes = $reflection->getAttributes();
-        $immutable = false;
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Immutable::class) {
-                $attribute->newInstance();
-                $immutable = true;
-            }
-        }
-
-        return $immutable;
+        return AttributeHelper::getInstances($reflection, Immutable::class) !== [];
     }
 }
 
diff --git a/tests/ImportTypeTest.php b/tests/ImportTypeTest.php
index 1439454..d8ce1cb 100644
--- a/tests/ImportTypeTest.php
+++ b/tests/ImportTypeTest.php
@@ -28,14 +28,10 @@ public function testClassTypes(): void
     public static function getPropertiesFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, ImportType::class);
         $properties = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === ImportType::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof ImportType);
-                $properties = array_merge($properties, $instance->from);
-            }
+        foreach ($instances as $instance) {
+            $properties = array_merge($properties, $instance->from);
         }
 
         return $properties;
diff --git a/tests/ImpureTest.php b/tests/ImpureTest.php
index c701615..5fe8978 100644
--- a/tests/ImpureTest.php
+++ b/tests/ImpureTest.php
@@ -32,16 +32,7 @@ private function getImpure(string $methodName): bool
     public static function getImpureFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): bool {
-        $attributes = $reflection->getAttributes();
-        $impure = false;
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Impure::class) {
-                $attribute->newInstance();
-                $impure = true;
-            }
-        }
-
-        return $impure;
+        return AttributeHelper::getInstances($reflection, Impure::class) !== [];
     }
 }
 
diff --git a/tests/IsReadOnlyTest.php b/tests/IsReadOnlyTest.php
index f320802..13a8bea 100644
--- a/tests/IsReadOnlyTest.php
+++ b/tests/IsReadOnlyTest.php
@@ -64,15 +64,6 @@ private function multipleReadOnly(): bool
     private function getReadOnly(string $propertyName): bool
     {
         $reflection = new ReflectionProperty($this, $propertyName);
-        $attributes = $reflection->getAttributes();
-        $isReadOnly = false;
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === IsReadOnly::class) {
-                $attribute->newInstance();
-                $isReadOnly = true;
-            }
-        }
-
-        return $isReadOnly;
+        return AttributeHelper::getInstances($reflection, IsReadOnly::class) !== [];
     }
 }
diff --git a/tests/MethodTest.php b/tests/MethodTest.php
index e387fe9..f9018e8 100644
--- a/tests/MethodTest.php
+++ b/tests/MethodTest.php
@@ -25,14 +25,10 @@ public function testClassMethods(): void
     public static function getMethodsFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Method::class);
         $methods = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Method::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Method);
-                $methods = array_merge($methods, $instance->methods);
-            }
+        foreach ($instances as $instance) {
+            $methods = array_merge($methods, $instance->methods);
         }
 
         return $methods;
diff --git a/tests/MixinTest.php b/tests/MixinTest.php
index 213dc6d..35444bb 100644
--- a/tests/MixinTest.php
+++ b/tests/MixinTest.php
@@ -33,14 +33,10 @@ public function testClassMixins(): void
     public static function getMixinsFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Mixin::class);
         $mixins = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Mixin::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Mixin);
-                $mixins = array_merge($mixins, $instance->classes);
-            }
+        foreach ($instances as $instance) {
+            $mixins = array_merge($mixins, $instance->classes);
         }
 
         return $mixins;
diff --git a/tests/ParamOutTest.php b/tests/ParamOutTest.php
index 0c72ea1..0e4f353 100644
--- a/tests/ParamOutTest.php
+++ b/tests/ParamOutTest.php
@@ -111,26 +111,17 @@ private function getParamOuts(string $functionName): array
     public static function getParamOutsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getFunctionInstances($reflection, ParamOut::class);
         $paramOuts = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === ParamOut::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof ParamOut);
-                $paramOuts = array_merge($paramOuts, $instance->params);
-            }
+
+        foreach ($instances['function'] as $instance) {
+            $paramOuts = array_merge($paramOuts, $instance->params);
         }
 
-        $parameters = $reflection->getParameters();
-        foreach ($parameters as $parameter) {
-            $attributes = $parameter->getAttributes();
-            foreach ($attributes as $attribute) {
-                if ($attribute->getName() === ParamOut::class) {
-                    $instance = $attribute->newInstance();
-                    assert($instance instanceof ParamOut);
-                    $argument = $instance->params[array_key_first($instance->params)];
-                    $paramOuts[$parameter->name] = $argument;
-                }
+        foreach ($instances['parameters'] as $name => $attrs) {
+            foreach ($attrs as $instance) {
+                $argument = $instance->params[array_key_first($instance->params)];
+                $paramOuts[$name] = $argument;
             }
         }
 
diff --git a/tests/ParamTest.php b/tests/ParamTest.php
index bea8f5d..7ad6d74 100644
--- a/tests/ParamTest.php
+++ b/tests/ParamTest.php
@@ -115,26 +115,17 @@ private function getParams(string $functionName): array
     public static function getParamsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getFunctionInstances($reflection, Param::class);
         $params = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Param::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Param);
-                $params = array_merge($params, $instance->params);
-            }
+
+        foreach ($instances['function'] as $instance) {
+            $params = array_merge($params, $instance->params);
         }
 
-        $parameters = $reflection->getParameters();
-        foreach ($parameters as $parameter) {
-            $attributes = $parameter->getAttributes();
-            foreach ($attributes as $attribute) {
-                if ($attribute->getName() === Param::class) {
-                    $instance = $attribute->newInstance();
-                    assert($instance instanceof Param);
-                    $argument = $instance->params[array_key_first($instance->params)];
-                    $params[$parameter->name] = $argument;
-                }
+        foreach ($instances['parameters'] as $name => $attrs) {
+            foreach ($attrs as $instance) {
+                $argument = $instance->params[array_key_first($instance->params)];
+                $params[$name] = $argument;
             }
         }
 
diff --git a/tests/PropertyReadTest.php b/tests/PropertyReadTest.php
index 4729fe5..45b32bd 100644
--- a/tests/PropertyReadTest.php
+++ b/tests/PropertyReadTest.php
@@ -27,14 +27,10 @@ public function testClassProperties(): void
     public static function getPropertiesFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, PropertyRead::class);
         $properties = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === PropertyRead::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof PropertyRead);
-                $properties = array_merge($properties, $instance->properties);
-            }
+        foreach ($instances as $instance) {
+            $properties = array_merge($properties, $instance->properties);
         }
 
         return $properties;
diff --git a/tests/PropertyTest.php b/tests/PropertyTest.php
index 4706195..8dfb846 100644
--- a/tests/PropertyTest.php
+++ b/tests/PropertyTest.php
@@ -36,14 +36,10 @@ public function testPropertyProperties(): void
     public static function getPropertiesFromReflection(
         ReflectionProperty | ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Property::class);
         $properties = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Property::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Property);
-                $properties = array_merge($properties, $instance->properties);
-            }
+        foreach ($instances as $instance) {
+            $properties = array_merge($properties, $instance->properties);
         }
 
         return $properties;
diff --git a/tests/PropertyWriteTest.php b/tests/PropertyWriteTest.php
index a48e318..bba5cf7 100644
--- a/tests/PropertyWriteTest.php
+++ b/tests/PropertyWriteTest.php
@@ -27,14 +27,10 @@ public function testClassProperties(): void
     public static function getPropertiesFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, PropertyWrite::class);
         $properties = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === PropertyWrite::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof PropertyWrite);
-                $properties = array_merge($properties, $instance->properties);
-            }
+        foreach ($instances as $instance) {
+            $properties = array_merge($properties, $instance->properties);
         }
 
         return $properties;
diff --git a/tests/PureTest.php b/tests/PureTest.php
index d2b9b06..ffbf2e9 100644
--- a/tests/PureTest.php
+++ b/tests/PureTest.php
@@ -32,16 +32,7 @@ private function getPure(string $methodName): bool
     public static function getPureFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): bool {
-        $attributes = $reflection->getAttributes();
-        $pure = false;
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Pure::class) {
-                $attribute->newInstance();
-                $pure = true;
-            }
-        }
-
-        return $pure;
+        return AttributeHelper::getInstances($reflection, Pure::class) !== [];
     }
 }
 
diff --git a/tests/RequireExtendsTest.php b/tests/RequireExtendsTest.php
index 990ed08..af35702 100644
--- a/tests/RequireExtendsTest.php
+++ b/tests/RequireExtendsTest.php
@@ -16,14 +16,10 @@ public function testClassRequireExtends(): void
     public static function getRequireExtendssFromReflection(
         ReflectionClass $reflection
     ): string {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, RequireExtends::class);
         $extends = '';
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === RequireExtends::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof RequireExtends);
-                $extends = $instance->class;
-            }
+        foreach ($instances as $instance) {
+            $extends = $instance->class;
         }
 
         return $extends;
diff --git a/tests/RequireImplementsTest.php b/tests/RequireImplementsTest.php
index bb5bb77..fa1faa9 100644
--- a/tests/RequireImplementsTest.php
+++ b/tests/RequireImplementsTest.php
@@ -22,14 +22,10 @@ public function testClassRequireImplements(): void
     public static function getRequireImplementssFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, RequireImplements::class);
         $implements = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === RequireImplements::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof RequireImplements);
-                $implements = array_merge($implements, $instance->interfaces);
-            }
+        foreach ($instances as $instance) {
+            $implements = array_merge($implements, $instance->interfaces);
         }
 
         return $implements;
diff --git a/tests/ReturnsTest.php b/tests/ReturnsTest.php
index 08a9c8c..343b500 100644
--- a/tests/ReturnsTest.php
+++ b/tests/ReturnsTest.php
@@ -89,14 +89,10 @@ private function getReturns(string $methodName): string
     public static function getReturnsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): string {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Returns::class);
         $returns = '';
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Returns::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Returns);
-                $returns = $instance->type;
-            }
+        foreach ($instances as $instance) {
+            $returns = $instance->type;
         }
 
         return $returns;
diff --git a/tests/SelfOutTest.php b/tests/SelfOutTest.php
index 0f0c778..741d0fd 100644
--- a/tests/SelfOutTest.php
+++ b/tests/SelfOutTest.php
@@ -80,14 +80,10 @@ private function multipleMethodSelfOut(): string
     private function getSelfOut(string $methodName): string
     {
         $reflection = new ReflectionMethod($this, $methodName);
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, SelfOut::class);
         $selfOut = '';
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === SelfOut::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof SelfOut);
-                $selfOut = $instance->type;
-            }
+        foreach ($instances as $instance) {
+            $selfOut = $instance->type;
         }
 
         return $selfOut;
diff --git a/tests/TemplateContravariantTest.php b/tests/TemplateContravariantTest.php
index eb8a04b..0666d55 100644
--- a/tests/TemplateContravariantTest.php
+++ b/tests/TemplateContravariantTest.php
@@ -30,18 +30,14 @@ public function testInterfaceTemplateContravariant(): void
     public static function getTemplateContravariantsFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, TemplateContravariant::class);
         $templates = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === TemplateContravariant::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof TemplateContravariant);
-                $templateValue = $instance->name;
-                if ($instance->of !== null) {
-                    $templateValue .= ' of ' . $instance->of;
-                }
-                $templates[] = $templateValue;
+        foreach ($instances as $instance) {
+            $templateValue = $instance->name;
+            if ($instance->of !== null) {
+                $templateValue .= ' of ' . $instance->of;
             }
+            $templates[] = $templateValue;
         }
 
         return $templates;
diff --git a/tests/TemplateCovariantTest.php b/tests/TemplateCovariantTest.php
index f9d41ba..882d53c 100644
--- a/tests/TemplateCovariantTest.php
+++ b/tests/TemplateCovariantTest.php
@@ -30,18 +30,14 @@ public function testInterfaceTemplateCovariant(): void
     public static function getTemplateCovariantsFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, TemplateCovariant::class);
         $templates = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === TemplateCovariant::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof TemplateCovariant);
-                $templateValue = $instance->name;
-                if ($instance->of !== null) {
-                    $templateValue .= ' of ' . $instance->of;
-                }
-                $templates[] = $templateValue;
+        foreach ($instances as $instance) {
+            $templateValue = $instance->name;
+            if ($instance->of !== null) {
+                $templateValue .= ' of ' . $instance->of;
             }
+            $templates[] = $templateValue;
         }
 
         return $templates;
diff --git a/tests/TemplateExtendsTest.php b/tests/TemplateExtendsTest.php
index dcf6787..158b5f9 100644
--- a/tests/TemplateExtendsTest.php
+++ b/tests/TemplateExtendsTest.php
@@ -17,14 +17,10 @@ public function testClassTemplateExtends(): void
     public static function getTemplateExtendssFromReflection(
         ReflectionClass $reflection
     ): string {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, TemplateExtends::class);
         $extends = '';
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === TemplateExtends::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof TemplateExtends);
-                $extends = $instance->class;
-            }
+        foreach ($instances as $instance) {
+            $extends = $instance->class;
         }
 
         return $extends;
diff --git a/tests/TemplateImplementsTest.php b/tests/TemplateImplementsTest.php
index 1fdcf9f..302c306 100644
--- a/tests/TemplateImplementsTest.php
+++ b/tests/TemplateImplementsTest.php
@@ -41,14 +41,10 @@ public function testClassTemplateImplements(): void
     public static function getTemplateImplementssFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, TemplateImplements::class);
         $implements = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === TemplateImplements::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof TemplateImplements);
-                $implements = array_merge($implements, $instance->interfaces);
-            }
+        foreach ($instances as $instance) {
+            $implements = array_merge($implements, $instance->interfaces);
         }
 
         return $implements;
diff --git a/tests/TemplateTest.php b/tests/TemplateTest.php
index bf6bbb5..8709fda 100644
--- a/tests/TemplateTest.php
+++ b/tests/TemplateTest.php
@@ -97,18 +97,14 @@ private function getTemplates(string $methodName): array
     public static function getTemplatesFromReflection(
         ReflectionMethod | ReflectionFunction | ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Template::class);
         $templates = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Template::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Template);
-                $templateValue = $instance->name;
-                if ($instance->of !== null) {
-                    $templateValue .= ' of ' . $instance->of;
-                }
-                $templates[] = $templateValue;
+        foreach ($instances as $instance) {
+            $templateValue = $instance->name;
+            if ($instance->of !== null) {
+                $templateValue .= ' of ' . $instance->of;
             }
+            $templates[] = $templateValue;
         }
 
         return $templates;
diff --git a/tests/TemplateUseTest.php b/tests/TemplateUseTest.php
index cab9409..b50eef3 100644
--- a/tests/TemplateUseTest.php
+++ b/tests/TemplateUseTest.php
@@ -43,14 +43,10 @@ public function testClassTemplateUse(): void
     public static function getTemplateUsesFromReflection(
         ReflectionClass $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, TemplateUse::class);
         $uses = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === TemplateUse::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof TemplateUse);
-                $uses = array_merge($uses, $instance->traits);
-            }
+        foreach ($instances as $instance) {
+            $uses = array_merge($uses, $instance->traits);
         }
 
         return $uses;
diff --git a/tests/ThrowsTest.php b/tests/ThrowsTest.php
index 83d8210..3a69e58 100644
--- a/tests/ThrowsTest.php
+++ b/tests/ThrowsTest.php
@@ -81,14 +81,10 @@ private function getThrows(string $functionName): array
     public static function getThrowsFromReflection(
         ReflectionMethod | ReflectionFunction $reflection
     ): array {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Throws::class);
         $throwss = [];
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Throws::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Throws);
-                $throwss = array_merge($throwss, $instance->exceptions);
-            }
+        foreach ($instances as $instance) {
+            $throwss = array_merge($throwss, $instance->exceptions);
         }
 
         return $throwss;
diff --git a/tests/TypeTest.php b/tests/TypeTest.php
index ed078d5..b0f110a 100644
--- a/tests/TypeTest.php
+++ b/tests/TypeTest.php
@@ -132,14 +132,10 @@ private function getMethodType(string $methodName): string
     public static function getTypeFromReflection(
         ReflectionProperty | ReflectionClassConstant | ReflectionMethod | ReflectionFunction | ReflectionClass $reflection
     ): string {
-        $attributes = $reflection->getAttributes();
+        $instances = AttributeHelper::getInstances($reflection, Type::class);
         $type = '';
-        foreach ($attributes as $attribute) {
-            if ($attribute->getName() === Type::class) {
-                $instance = $attribute->newInstance();
-                assert($instance instanceof Type);
-                $type = $instance->type;
-            }
+        foreach ($instances as $instance) {
+            $type = $instance->type;
         }
 
         return $type;