From b31629bb291308a673bcc34ee90e9a165c17ea93 Mon Sep 17 00:00:00 2001
From: Alexander Linne <alexander.linne@tngtech.com>
Date: Tue, 26 Aug 2025 21:27:01 +0200
Subject: [PATCH 1/2] Refactor Object Syntax Elements

Signed-off-by: Alexander Linne <alexander.linne@tngtech.com>
---
 .../Domain/Extensions/EnumerableExtensions.cs |   21 +
 .../Domain/Extensions/NamingExtensions.cs     |   74 +-
 ArchUnitNET/Domain/IObjectProvider.cs         |    6 +
 .../{Fluent => Domain}/ObjectProvider.cs      |   29 +-
 .../SystemTypeObjectProvider.cs               |   27 +-
 ArchUnitNET/Fluent/BasicObjectProvider.cs     |    9 +
 ArchUnitNET/Fluent/Slices/GivenSlices.cs      |    9 +
 .../Fluent/Syntax/DescriptionHelpers.cs       |   29 -
 .../Fluent/Syntax/Elements/GivenObjects.cs    |    9 +
 .../GivenObjectsConjunctionWithDescription.cs |    9 +
 .../Syntax/Elements/GivenObjectsThat.cs       | 1061 ++------------
 .../Elements/IComplexObjectConditions.cs      |   33 +-
 .../Syntax/Elements/IObjectConditions.cs      |  211 ++-
 .../Syntax/Elements/IObjectPredicates.cs      |  211 ++-
 .../Elements/ObjectConditionsDefinition.cs    |  502 ++++---
 .../Elements/ObjectPredicatesDefinition.cs    | 1057 +++-----------
 .../Fluent/Syntax/Elements/ObjectsShould.cs   | 1236 ++---------------
 .../Elements/ShouldRelateToObjectsThat.cs     | 1123 ++-------------
 .../Types/TypeConditionsDefinition.cs         |   11 +-
 .../Types/TypePredicatesDefinition.cs         |   11 +-
 .../ObjectConditionsErrorMessagesTests.cs     |   81 --
 .../Elements/ObjectSyntaxElementsTests.cs     | 1145 ++++++++-------
 ...ectSyntaxElementsTests.BeTest.verified.txt |    9 +
 ...ntaxElementsTests.CallAnyTest.verified.txt |  119 +-
 ...ElementsTests.DependOnAnyTest.verified.txt |  219 +--
 ...ests.DependOnAnyTypesThatTest.verified.txt |    4 +-
 ...tsTests.HaveAnyAttributesTest.verified.txt |  212 +--
 ...sts.HaveAnyAttributesThatTest.verified.txt |    4 +-
 ...taxElementsTests.HaveNameTest.verified.txt |  533 +++++--
 ...SyntaxElementsTests.NotBeTest.verified.txt |   32 +-
 ...xElementsTests.NotCallAnyTest.verified.txt |  130 +-
 ...mentsTests.NotDependOnAnyTest.verified.txt |  222 +--
 ...s.NotDependOnAnyTypesThatTest.verified.txt |    4 +-
 ...ests.NotHaveAnyAttributesTest.verified.txt |  200 +--
 ...ElementsTests.NotHaveNameTest.verified.txt |  401 +++++-
 ...lementsTests.OnlyDependOnTest.verified.txt |   67 +-
 ...sTests.OnlyHaveAttributesTest.verified.txt |  191 +--
 ...ts.ImplementAnyInterfacesTest.verified.txt |    6 +-
 ...NotImplementAnyInterfacesTest.verified.txt |    6 +-
 39 files changed, 3491 insertions(+), 5772 deletions(-)
 rename ArchUnitNET/{Fluent => Domain}/ObjectProvider.cs (57%)
 rename ArchUnitNET/{Fluent => Domain}/SystemTypeObjectProvider.cs (66%)
 delete mode 100644 ArchUnitNET/Fluent/Syntax/DescriptionHelpers.cs
 delete mode 100644 ArchUnitNETTests/Fluent/ObjectConditionsErrorMessagesTests.cs

diff --git a/ArchUnitNET/Domain/Extensions/EnumerableExtensions.cs b/ArchUnitNET/Domain/Extensions/EnumerableExtensions.cs
index 944b4c86d..a2f9eced9 100644
--- a/ArchUnitNET/Domain/Extensions/EnumerableExtensions.cs
+++ b/ArchUnitNET/Domain/Extensions/EnumerableExtensions.cs
@@ -21,5 +21,26 @@ public static bool IsNullOrEmpty<T>(this IEnumerable<T> source)
         {
             return source == null || !source.Any();
         }
+
+        public static string FormatDescription<T>(
+            this IEnumerable<T> source,
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription,
+            Func<T, string> elementDescription = null
+        )
+        {
+            var list = source as IList<T> ?? source.ToList();
+            elementDescription = elementDescription ?? (element => $"\"{element}\"");
+            switch (list.Count)
+            {
+                case 0:
+                    return emptyDescription;
+                case 1:
+                    return $"{singleDescription} {string.Join(" and ", list.Select(elementDescription))}";
+                default:
+                    return $"{multipleDescription} {string.Join(" and ", list.Select(elementDescription))}";
+            }
+        }
     }
 }
diff --git a/ArchUnitNET/Domain/Extensions/NamingExtensions.cs b/ArchUnitNET/Domain/Extensions/NamingExtensions.cs
index 69a71f529..441a646b8 100644
--- a/ArchUnitNET/Domain/Extensions/NamingExtensions.cs
+++ b/ArchUnitNET/Domain/Extensions/NamingExtensions.cs
@@ -9,6 +9,16 @@ namespace ArchUnitNET.Domain.Extensions
 {
     public static class NamingExtensions
     {
+        public static bool NameEquals(this IHasName cls, string name)
+        {
+            return string.Equals(cls.Name, name, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static bool NameMatches(this IHasName cls, string pattern)
+        {
+            return pattern != null && Regex.IsMatch(cls.Name, pattern);
+        }
+
         public static bool NameEndsWith(
             this IHasName cls,
             string pattern,
@@ -36,24 +46,24 @@ public static bool NameContains(
             return cls.Name.IndexOf(pattern, stringComparison) >= 0;
         }
 
-        public static bool NameEquals(this IHasName cls, string name)
+        public static bool FullNameEquals(this IHasName cls, string fullName)
         {
-            return string.Equals(cls.Name, name, StringComparison.OrdinalIgnoreCase);
+            return string.Equals(cls.FullName, fullName, StringComparison.OrdinalIgnoreCase);
         }
 
-        public static bool NameMatches(this IHasName cls, string pattern)
+        public static bool FullNameMatches(this IHasName cls, string pattern)
         {
-            return pattern != null && Regex.IsMatch(cls.Name, pattern);
+            return pattern != null && Regex.IsMatch(cls.FullName, pattern);
         }
 
-        public static bool FullNameEquals(this IHasName cls, string fullName)
+        public static bool FullNameEndsWith(this IHasName cls, string pattern)
         {
-            return string.Equals(cls.FullName, fullName, StringComparison.OrdinalIgnoreCase);
+            return cls.FullName.EndsWith(pattern, StringComparison.OrdinalIgnoreCase);
         }
 
-        public static bool FullNameMatches(this IHasName cls, string pattern)
+        public static bool FullNameStartsWith(this IHasName cls, string pattern)
         {
-            return pattern != null && Regex.IsMatch(cls.FullName, pattern);
+            return cls.FullName.StartsWith(pattern, StringComparison.OrdinalIgnoreCase);
         }
 
         public static bool FullNameContains(this IHasName cls, string pattern)
@@ -61,6 +71,54 @@ public static bool FullNameContains(this IHasName cls, string pattern)
             return pattern != null && cls.FullName.ToLower().Contains(pattern.ToLower());
         }
 
+        public static bool AssemblyQualifiedNameEquals(
+            this IHasAssemblyQualifiedName cls,
+            string assemblyQualifiedName
+        )
+        {
+            return string.Equals(
+                cls.AssemblyQualifiedName,
+                assemblyQualifiedName,
+                StringComparison.OrdinalIgnoreCase
+            );
+        }
+
+        public static bool AssemblyQualifiedNameMatches(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return pattern != null && Regex.IsMatch(cls.AssemblyQualifiedName, pattern);
+        }
+
+        public static bool AssemblyQualifiedNameEndsWith(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return cls.AssemblyQualifiedName.EndsWith(pattern, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static bool AssemblyQualifiedNameStartsWith(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return cls.AssemblyQualifiedName.StartsWith(
+                pattern,
+                StringComparison.OrdinalIgnoreCase
+            );
+        }
+
+        public static bool AssemblyQualifiedNameContains(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return pattern != null
+                && cls.AssemblyQualifiedName.ToLower().Contains(pattern.ToLower());
+        }
+
         [NotNull]
         public static IEnumerable<TType> WhereNameIs<TType>(
             this IEnumerable<TType> source,
diff --git a/ArchUnitNET/Domain/IObjectProvider.cs b/ArchUnitNET/Domain/IObjectProvider.cs
index a38343c4b..8b60e8abf 100644
--- a/ArchUnitNET/Domain/IObjectProvider.cs
+++ b/ArchUnitNET/Domain/IObjectProvider.cs
@@ -5,5 +5,11 @@ namespace ArchUnitNET.Domain
     public interface IObjectProvider<out T> : IHasDescription
     {
         IEnumerable<T> GetObjects(Architecture architecture);
+
+        string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        );
     }
 }
diff --git a/ArchUnitNET/Fluent/ObjectProvider.cs b/ArchUnitNET/Domain/ObjectProvider.cs
similarity index 57%
rename from ArchUnitNET/Fluent/ObjectProvider.cs
rename to ArchUnitNET/Domain/ObjectProvider.cs
index 1a23dcd5a..c011287e3 100644
--- a/ArchUnitNET/Fluent/ObjectProvider.cs
+++ b/ArchUnitNET/Domain/ObjectProvider.cs
@@ -4,7 +4,7 @@
 
 namespace ArchUnitNET.Fluent
 {
-    public class ObjectProvider<T> : ISizedObjectProvider<T>
+    internal class ObjectProvider<T> : ISizedObjectProvider<T>
         where T : ICanBeAnalyzed
     {
         private readonly List<T> _objects;
@@ -20,16 +20,32 @@ public ObjectProvider(IEnumerable<T> objects)
 
         public string Description { get; }
 
-        public int Count => _objects.Count();
+        public int Count => _objects.Count;
 
         public IEnumerable<T> GetObjects(Architecture architecture)
         {
             return _objects;
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            switch (Count)
+            {
+                case 0:
+                    return emptyDescription;
+                case 1:
+                    return $"{singleDescription} {Description}";
+            }
+            return $"{multipleDescription} {Description}";
+        }
+
         private bool Equals(ObjectProvider<T> other)
         {
-            return string.Equals(Description, other.Description);
+            return _objects.SequenceEqual(other._objects);
         }
 
         public override bool Equals(object obj)
@@ -49,7 +65,12 @@ public override bool Equals(object obj)
 
         public override int GetHashCode()
         {
-            return Description != null ? Description.GetHashCode() : 0;
+            return _objects != null
+                ? _objects.Aggregate(
+                    0,
+                    (current, obj) => (current * 397) ^ (obj?.GetHashCode() ?? 0)
+                )
+                : 0;
         }
     }
 }
diff --git a/ArchUnitNET/Fluent/SystemTypeObjectProvider.cs b/ArchUnitNET/Domain/SystemTypeObjectProvider.cs
similarity index 66%
rename from ArchUnitNET/Fluent/SystemTypeObjectProvider.cs
rename to ArchUnitNET/Domain/SystemTypeObjectProvider.cs
index 1c90280c3..e8d29ab89 100644
--- a/ArchUnitNET/Fluent/SystemTypeObjectProvider.cs
+++ b/ArchUnitNET/Domain/SystemTypeObjectProvider.cs
@@ -6,7 +6,7 @@
 
 namespace ArchUnitNET.Fluent
 {
-    public class SystemTypeObjectProvider<T> : ISizedObjectProvider<T>
+    internal class SystemTypeObjectProvider<T> : ISizedObjectProvider<T>
         where T : IType
     {
         private readonly List<Type> _types;
@@ -37,9 +37,25 @@ public IEnumerable<T> GetObjects(Architecture architecture)
                 );
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            switch (Count)
+            {
+                case 0:
+                    return emptyDescription;
+                case 1:
+                    return $"{singleDescription} {Description}";
+            }
+            return $"{multipleDescription} {Description}";
+        }
+
         private bool Equals(SystemTypeObjectProvider<T> other)
         {
-            return string.Equals(Description, other.Description);
+            return _types.SequenceEqual(other._types);
         }
 
         public override bool Equals(object obj)
@@ -59,7 +75,12 @@ public override bool Equals(object obj)
 
         public override int GetHashCode()
         {
-            return Description != null ? Description.GetHashCode() : 0;
+            return _types != null
+                ? _types.Aggregate(
+                    0,
+                    (current, type) => (current * 397) ^ (type?.GetHashCode() ?? 0)
+                )
+                : 0;
         }
     }
 }
diff --git a/ArchUnitNET/Fluent/BasicObjectProvider.cs b/ArchUnitNET/Fluent/BasicObjectProvider.cs
index 8a70538af..f10e1df9a 100644
--- a/ArchUnitNET/Fluent/BasicObjectProvider.cs
+++ b/ArchUnitNET/Fluent/BasicObjectProvider.cs
@@ -22,6 +22,15 @@ public IEnumerable<T> GetObjects(Architecture architecture)
             return architecture.GetOrCreateObjects(this, _objects);
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
+
         public override string ToString()
         {
             return Description;
diff --git a/ArchUnitNET/Fluent/Slices/GivenSlices.cs b/ArchUnitNET/Fluent/Slices/GivenSlices.cs
index 78fe4a193..59e4b9524 100644
--- a/ArchUnitNET/Fluent/Slices/GivenSlices.cs
+++ b/ArchUnitNET/Fluent/Slices/GivenSlices.cs
@@ -24,5 +24,14 @@ public IEnumerable<Slice> GetObjects(Architecture architecture)
         {
             return _ruleCreator.GetSlices(architecture);
         }
+
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
     }
 }
diff --git a/ArchUnitNET/Fluent/Syntax/DescriptionHelpers.cs b/ArchUnitNET/Fluent/Syntax/DescriptionHelpers.cs
deleted file mode 100644
index a9da7715e..000000000
--- a/ArchUnitNET/Fluent/Syntax/DescriptionHelpers.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using ArchUnitNET.Domain;
-
-namespace ArchUnitNET.Fluent.Syntax
-{
-    public static class DescriptionHelpers
-    {
-        public static string SelectDescription<T>(
-            string emptyDescription,
-            string singleDescription,
-            string multipleDescription,
-            IObjectProvider<T> objectProvider
-        )
-        {
-            if (!(objectProvider is ISizedObjectProvider<T> sizedObjectProvider))
-            {
-                return $"{multipleDescription} {objectProvider.Description}";
-            }
-
-            switch (sizedObjectProvider.Count)
-            {
-                case 0:
-                    return emptyDescription;
-                case 1:
-                    return $"{singleDescription} {objectProvider.Description}";
-            }
-            return $"{multipleDescription} {objectProvider.Description}";
-        }
-    }
-}
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/GivenObjects.cs b/ArchUnitNET/Fluent/Syntax/Elements/GivenObjects.cs
index c7fb07a7e..21a835389 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/GivenObjects.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/GivenObjects.cs
@@ -30,6 +30,15 @@ public IEnumerable<TRuleType> GetObjects(Architecture architecture)
             }
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
+
         public TRuleTypeThat That()
         {
             return Create<TRuleTypeThat, TRuleType>(_ruleCreator);
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsConjunctionWithDescription.cs b/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsConjunctionWithDescription.cs
index 0b1816094..3873a9417 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsConjunctionWithDescription.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsConjunctionWithDescription.cs
@@ -32,6 +32,15 @@ public IEnumerable<TRuleType> GetObjects(Architecture architecture)
             }
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
+
         public TGivenRuleTypeThat And()
         {
             _ruleCreator.AddPredicateConjunction(LogicalConjunctionDefinition.And);
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsThat.cs b/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsThat.cs
index 4f52ba5f5..6263e0001 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsThat.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsThat.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using ArchUnitNET.Domain;
 using ArchUnitNET.Fluent.Predicates;
 using static ArchUnitNET.Fluent.Syntax.ConjunctionFactory;
@@ -15,921 +16,157 @@ public abstract class GivenObjectsThat<TGivenRuleTypeConjunction, TRuleType>
         protected GivenObjectsThat(IArchRuleCreator<TRuleType> ruleCreator)
             : base(ruleCreator) { }
 
-        public TGivenRuleTypeConjunction Are(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.Are(firstObject, moreObjects)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction Are(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.Are(objects));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction Are(IObjectProvider<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.Are(objects));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction CallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.CallAny(method, moreMethods)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction CallAny(IEnumerable<MethodMember> methods)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.CallAny(methods));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction CallAny(IObjectProvider<MethodMember> methods)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.CallAny(methods));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DependOnAny(firstType, moreTypes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DependOnAny(firstType, moreTypes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DependOnAny(IObjectProvider<IType> types)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.DependOnAny(types));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DependOnAny(IEnumerable<IType> types)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.DependOnAny(types));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DependOnAny(IEnumerable<Type> types)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.DependOnAny(types));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction FollowCustomPredicate(IPredicate<TRuleType> predicate)
+        // csharpier-ignore-start
+        public TGivenRuleTypeConjunction FollowCustomPredicate(IPredicate<TRuleType> predicate) => AddPredicate(predicate);
+        public TGivenRuleTypeConjunction FollowCustomPredicate(Func<TRuleType, bool> predicate, string description) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.FollowCustomPredicate(predicate, description));
+
+        public TGivenRuleTypeConjunction Are(params ICanBeAnalyzed[] objects) => Are(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TGivenRuleTypeConjunction Are(IEnumerable<ICanBeAnalyzed> objects) => Are(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TGivenRuleTypeConjunction Are(IObjectProvider<ICanBeAnalyzed> objects) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.Are(objects));
+
+        public TGivenRuleTypeConjunction CallAny(params MethodMember[] methods) => CallAny(new ObjectProvider<MethodMember>(methods));
+        public TGivenRuleTypeConjunction CallAny(IEnumerable<MethodMember> methods) => CallAny(new ObjectProvider<MethodMember>(methods));
+        public TGivenRuleTypeConjunction CallAny(IObjectProvider<MethodMember> methods) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.CallAny(methods));
+
+        public TGivenRuleTypeConjunction DependOnAny() => DependOnAny(new ObjectProvider<IType>());
+        public TGivenRuleTypeConjunction DependOnAny(params IType[] types) => DependOnAny(new ObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction DependOnAny(params Type[] types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction DependOnAny(IObjectProvider<IType> types) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DependOnAny(types));
+        public TGivenRuleTypeConjunction DependOnAny(IEnumerable<IType> types) => DependOnAny(new ObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction DependOnAny(IEnumerable<Type> types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
+
+        public TGivenRuleTypeConjunction OnlyDependOn() => OnlyDependOn(new ObjectProvider<IType>());
+        public TGivenRuleTypeConjunction OnlyDependOn(params IType[] types) => OnlyDependOn(new ObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction OnlyDependOn(params Type[] types) => OnlyDependOn(new SystemTypeObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction OnlyDependOn(IObjectProvider<IType> types) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.OnlyDependOn(types));
+        public TGivenRuleTypeConjunction OnlyDependOn(IEnumerable<IType> types) => OnlyDependOn(new ObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction OnlyDependOn(IEnumerable<Type> types) => OnlyDependOn(new SystemTypeObjectProvider<IType>(types));
+
+        public TGivenRuleTypeConjunction HaveAnyAttributes() => HaveAnyAttributes(new ObjectProvider<Attribute>());
+        public TGivenRuleTypeConjunction HaveAnyAttributes(params Attribute[] attributes) => HaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction HaveAnyAttributes(params Type[] attributes) => HaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction HaveAnyAttributes(IObjectProvider<Attribute> attributes) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributes(attributes));
+        public TGivenRuleTypeConjunction HaveAnyAttributes(IEnumerable<Attribute> attributes) => HaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction HaveAnyAttributes(IEnumerable<Type> attributes) => HaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TGivenRuleTypeConjunction OnlyHaveAttributes() => OnlyHaveAttributes(new ObjectProvider<Attribute>());
+        public TGivenRuleTypeConjunction OnlyHaveAttributes(params Attribute[] attributes) => OnlyHaveAttributes(new ObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction OnlyHaveAttributes(params Type[] attributes) => OnlyHaveAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction OnlyHaveAttributes(IObjectProvider<Attribute> attributes) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.OnlyHaveAttributes(attributes));
+        public TGivenRuleTypeConjunction OnlyHaveAttributes(IEnumerable<Attribute> attributes) => OnlyHaveAttributes(new ObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction OnlyHaveAttributes(IEnumerable<Type> attributes) => OnlyHaveAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TGivenRuleTypeConjunction HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithArguments(argumentValues));
+        public TGivenRuleTypeConjunction HaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithArguments(new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TGivenRuleTypeConjunction HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(attribute, argumentValues));
+        public TGivenRuleTypeConjunction HaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+        public TGivenRuleTypeConjunction HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(attribute, argumentValues));
+        public TGivenRuleTypeConjunction HaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TGivenRuleTypeConjunction HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithNamedArguments(attributeArguments));
+        public TGivenRuleTypeConjunction HaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAnyAttributesWithNamedArguments(new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TGivenRuleTypeConjunction HaveName(string name) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveName(name));
+        public TGivenRuleTypeConjunction HaveNameMatching(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveNameMatching(pattern));
+        public TGivenRuleTypeConjunction HaveNameStartingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveNameStartingWith(pattern));
+        public TGivenRuleTypeConjunction HaveNameEndingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveNameEndingWith(pattern));
+        public TGivenRuleTypeConjunction HaveNameContaining(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveNameContaining(pattern));
+
+        public TGivenRuleTypeConjunction HaveFullName(string fullName) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveFullName(fullName));
+        public TGivenRuleTypeConjunction HaveFullNameMatching(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveFullNameMatching(pattern));
+        public TGivenRuleTypeConjunction HaveFullNameStartingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveFullNameStartingWith(pattern));
+        public TGivenRuleTypeConjunction HaveFullNameEndingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveFullNameEndingWith(pattern));
+        public TGivenRuleTypeConjunction HaveFullNameContaining(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveFullNameContaining(pattern));
+
+        public TGivenRuleTypeConjunction HaveAssemblyQualifiedName(string assemblyQualifiedName) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAssemblyQualifiedName(assemblyQualifiedName));
+        public TGivenRuleTypeConjunction HaveAssemblyQualifiedNameMatching(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAssemblyQualifiedNameMatching(pattern));
+        public TGivenRuleTypeConjunction HaveAssemblyQualifiedNameStartingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAssemblyQualifiedNameStartingWith(pattern));
+        public TGivenRuleTypeConjunction HaveAssemblyQualifiedNameEndingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAssemblyQualifiedNameEndingWith(pattern));
+        public TGivenRuleTypeConjunction HaveAssemblyQualifiedNameContaining(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveAssemblyQualifiedNameContaining(pattern));
+
+        public TGivenRuleTypeConjunction ArePrivate() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.ArePrivate());
+        public TGivenRuleTypeConjunction ArePublic() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.ArePublic());
+        public TGivenRuleTypeConjunction AreProtected() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreProtected());
+        public TGivenRuleTypeConjunction AreInternal() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreInternal());
+        public TGivenRuleTypeConjunction AreProtectedInternal() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreProtectedInternal());
+        public TGivenRuleTypeConjunction ArePrivateProtected() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.ArePrivateProtected());
+
+        // Negations
+
+        public TGivenRuleTypeConjunction AreNot(params ICanBeAnalyzed[] objects) => AreNot(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TGivenRuleTypeConjunction AreNot(IEnumerable<ICanBeAnalyzed> objects) => AreNot(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TGivenRuleTypeConjunction AreNot(IObjectProvider<ICanBeAnalyzed> objects) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNot(objects));
+
+        public TGivenRuleTypeConjunction DoNotCallAny(params MethodMember[] methods) => DoNotCallAny(new ObjectProvider<MethodMember>(methods));
+        public TGivenRuleTypeConjunction DoNotCallAny(IEnumerable<MethodMember> methods) => DoNotCallAny(new ObjectProvider<MethodMember>(methods));
+        public TGivenRuleTypeConjunction DoNotCallAny(IObjectProvider<MethodMember> methods) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotCallAny(methods));
+
+        public TGivenRuleTypeConjunction DoNotDependOnAny() => DoNotDependOnAny(new ObjectProvider<IType>());
+        public TGivenRuleTypeConjunction DoNotDependOnAny(params IType[] types) => DoNotDependOnAny(new ObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction DoNotDependOnAny(params Type[] types) => DoNotDependOnAny(new SystemTypeObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction DoNotDependOnAny(IObjectProvider<IType> types) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotDependOnAny(types));
+        public TGivenRuleTypeConjunction DoNotDependOnAny(IEnumerable<IType> types) => DoNotDependOnAny(new ObjectProvider<IType>(types));
+        public TGivenRuleTypeConjunction DoNotDependOnAny(IEnumerable<Type> types) => DoNotDependOnAny(new SystemTypeObjectProvider<IType>(types));
+
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes() => DoNotHaveAnyAttributes(new ObjectProvider<Attribute>());
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(params Attribute[] attributes) => DoNotHaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(params Type[] attributes) => DoNotHaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(IObjectProvider<Attribute> attributes) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributes(attributes));
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes) => DoNotHaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(IEnumerable<Type> attributes) => DoNotHaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithArguments(argumentValues));
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithArguments(new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(attribute, argumentValues));
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(attribute, argumentValues));
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithNamedArguments(attributeArguments));
+        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => DoNotHaveAnyAttributesWithNamedArguments(new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => DoNotHaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => DoNotHaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TGivenRuleTypeConjunction DoNotHaveName(string name) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveName(name));
+        public TGivenRuleTypeConjunction DoNotHaveNameMatching(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameMatching(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveNameStartingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameStartingWith(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveNameEndingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameEndingWith(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveNameContaining(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameContaining(pattern));
+
+        public TGivenRuleTypeConjunction DoNotHaveFullName(string fullName) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullName(fullName));
+        public TGivenRuleTypeConjunction DoNotHaveFullNameMatching(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullNameMatching(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveFullNameStartingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullNameStartingWith(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveFullNameEndingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullNameEndingWith(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveFullNameContaining(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullNameContaining(pattern));
+
+        public TGivenRuleTypeConjunction DoNotHaveAssemblyQualifiedName(string assemblyQualifiedName) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAssemblyQualifiedName(assemblyQualifiedName));
+        public TGivenRuleTypeConjunction DoNotHaveAssemblyQualifiedNameMatching(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAssemblyQualifiedNameMatching(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveAssemblyQualifiedNameStartingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAssemblyQualifiedNameStartingWith(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveAssemblyQualifiedNameEndingWith(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAssemblyQualifiedNameEndingWith(pattern));
+        public TGivenRuleTypeConjunction DoNotHaveAssemblyQualifiedNameContaining(string pattern) => AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveAssemblyQualifiedNameContaining(pattern));
+
+        public TGivenRuleTypeConjunction AreNotPrivate() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotPrivate());
+        public TGivenRuleTypeConjunction AreNotPublic() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotPublic());
+        public TGivenRuleTypeConjunction AreNotProtected() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotProtected());
+        public TGivenRuleTypeConjunction AreNotInternal() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotInternal());
+        public TGivenRuleTypeConjunction AreNotProtectedInternal() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotProtectedInternal());
+        public TGivenRuleTypeConjunction AreNotPrivateProtected() => AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotPrivateProtected());
+        // csharpier-ignore-end
+
+        private TGivenRuleTypeConjunction AddPredicate(IPredicate<TRuleType> predicate)
         {
             _ruleCreator.AddPredicate(predicate);
             return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
         }
-
-        public TGivenRuleTypeConjunction FollowCustomPredicate(
-            Func<TRuleType, bool> predicate,
-            string description
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.FollowCustomPredicate(predicate, description)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyDependOn(Type firstType, params Type[] moreTypes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyDependOn(firstType, moreTypes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyDependOn(IType firstType, params IType[] moreTypes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyDependOn(firstType, moreTypes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyDependOn(IObjectProvider<IType> types)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.OnlyDependOn(types));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyDependOn(IEnumerable<IType> types)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.OnlyDependOn(types));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyDependOn(IEnumerable<Type> types)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.OnlyDependOn(types));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributes(IObjectProvider<Attribute> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyHaveAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyHaveAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyHaveAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyHaveAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyHaveAttributes(IObjectProvider<Attribute> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyHaveAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction OnlyHaveAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributesWithArguments(
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithArguments(argumentValues)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithArguments(
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithNamedArguments(
-                    attributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAnyAttributesWithNamedArguments(
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveName(string name)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveName(name));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveNameMatching(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveNameMatching(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveFullName(string fullName)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.HaveFullName(fullName));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveFullNameMatching(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveFullNameMatching(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveNameStartingWith(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveNameStartingWith(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveNameEndingWith(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveNameEndingWith(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveNameContaining(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveNameContaining(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction HaveFullNameContaining(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.HaveFullNameContaining(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction ArePrivate()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.ArePrivate());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction ArePublic()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.ArePublic());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreProtected()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreProtected());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreInternal()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreInternal());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreProtectedInternal()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreProtectedInternal());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction ArePrivateProtected()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.ArePrivateProtected());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        //Negations
-
-        public TGivenRuleTypeConjunction AreNot(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.AreNot(firstObject, moreObjects)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNot(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNot(objects));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNot(IObjectProvider<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNot(objects));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotCallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotCallAny(method, moreMethods)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotCallAny(IEnumerable<MethodMember> methods)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotCallAny(methods));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotCallAny(IObjectProvider<MethodMember> methods)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotCallAny(methods));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotDependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotDependOnAny(firstType, moreTypes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotDependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotDependOnAny(firstType, moreTypes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotDependOnAny(IObjectProvider<IType> types)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotDependOnAny(types)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotDependOnAny(IEnumerable<IType> types)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotDependOnAny(types)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotDependOnAny(IEnumerable<Type> types)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotDependOnAny(types)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(
-            IObjectProvider<Attribute> attributes
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributes(attributes)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithArguments(
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithArguments(
-                    argumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithArguments(
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithNamedArguments(
-                    attributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAnyAttributesWithNamedArguments(
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveName(string name)
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.DoNotHaveName(name));
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveNameMatching(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameMatching(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveFullName(string fullName)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullName(fullName)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveFullNameMatching(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullNameMatching(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveNameStartingWith(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameStartingWith(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveNameEndingWith(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameEndingWith(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveNameContaining(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveNameContaining(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction DoNotHaveFullNameContaining(string pattern)
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.DoNotHaveFullNameContaining(pattern)
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNotPrivate()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotPrivate());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNotPublic()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotPublic());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNotProtected()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotProtected());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNotInternal()
-        {
-            _ruleCreator.AddPredicate(ObjectPredicatesDefinition<TRuleType>.AreNotInternal());
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNotProtectedInternal()
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.AreNotProtectedInternal()
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TGivenRuleTypeConjunction AreNotPrivateProtected()
-        {
-            _ruleCreator.AddPredicate(
-                ObjectPredicatesDefinition<TRuleType>.AreNotPrivateProtected()
-            );
-            return Create<TGivenRuleTypeConjunction, TRuleType>(_ruleCreator);
-        }
     }
 }
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/IComplexObjectConditions.cs b/ArchUnitNET/Fluent/Syntax/Elements/IComplexObjectConditions.cs
index 256b56bbb..94365eb0b 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/IComplexObjectConditions.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/IComplexObjectConditions.cs
@@ -9,32 +9,17 @@ public interface IComplexObjectConditions<TRuleTypeShouldConjunction, TRuleType>
         where TRuleType : ICanBeAnalyzed
         where TRuleTypeShouldConjunction : SyntaxElement<TRuleType>
     {
-        ShouldRelateToTypesThat<
-            TRuleTypeShouldConjunction,
-            IType,
-            TRuleType
-        > DependOnAnyTypesThat();
-        ShouldRelateToTypesThat<
-            TRuleTypeShouldConjunction,
-            IType,
-            TRuleType
-        > OnlyDependOnTypesThat();
+        // csharpier-ignore-start
+        ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType> DependOnAnyTypesThat();
+        ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType> OnlyDependOnTypesThat();
+
         ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> HaveAnyAttributesThat();
-        ShouldRelateToAttributesThat<
-            TRuleTypeShouldConjunction,
-            TRuleType
-        > OnlyHaveAttributesThat();
+        ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> OnlyHaveAttributesThat();
 
-        //Negations
+        // Negations
 
-        ShouldRelateToTypesThat<
-            TRuleTypeShouldConjunction,
-            IType,
-            TRuleType
-        > NotDependOnAnyTypesThat();
-        ShouldRelateToAttributesThat<
-            TRuleTypeShouldConjunction,
-            TRuleType
-        > NotHaveAnyAttributesThat();
+        ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType> NotDependOnAnyTypesThat();
+        ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> NotHaveAnyAttributesThat();
+        // csharpier-ignore-end
     }
 }
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/IObjectConditions.cs b/ArchUnitNET/Fluent/Syntax/Elements/IObjectConditions.cs
index aa7ef0c7c..f24377d86 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/IObjectConditions.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/IObjectConditions.cs
@@ -9,106 +9,84 @@ namespace ArchUnitNET.Fluent.Syntax.Elements
     public interface IObjectConditions<out TReturnType, out TRuleType>
         where TRuleType : ICanBeAnalyzed
     {
+        // csharpier-ignore-start
+
         TReturnType Exist();
 
-        TReturnType Be(ICanBeAnalyzed firstObject, params ICanBeAnalyzed[] moreObjects);
+        TReturnType Be(params ICanBeAnalyzed[] objects);
         TReturnType Be(IEnumerable<ICanBeAnalyzed> objects);
         TReturnType Be(IObjectProvider<ICanBeAnalyzed> objects);
 
-        TReturnType CallAny(MethodMember method, params MethodMember[] moreMethods);
+        TReturnType CallAny(params MethodMember[] methods);
         TReturnType CallAny(IEnumerable<MethodMember> methods);
         TReturnType CallAny(IObjectProvider<MethodMember> methods);
 
-        TReturnType DependOnAny(IType firstType, params IType[] moreTypes);
-        TReturnType DependOnAny(Type firstType, params Type[] moreTypes);
+        TReturnType DependOnAny();
+        TReturnType DependOnAny(params IType[] types);
+        TReturnType DependOnAny(params Type[] types);
         TReturnType DependOnAny(IObjectProvider<IType> types);
         TReturnType DependOnAny(IEnumerable<IType> types);
         TReturnType DependOnAny(IEnumerable<Type> types);
+
         TReturnType FollowCustomCondition(ICondition<TRuleType> condition);
-        TReturnType FollowCustomCondition(
-            Func<TRuleType, ConditionResult> condition,
-            string description
-        );
-        TReturnType FollowCustomCondition(
-            Func<TRuleType, bool> condition,
-            string description,
-            string failDescription
-        );
-
-        TReturnType OnlyDependOn(IType firstType, params IType[] moreTypes);
-        TReturnType OnlyDependOn(Type firstType, params Type[] moreTypes);
+        TReturnType FollowCustomCondition(Func<TRuleType, ConditionResult> condition, string description);
+        TReturnType FollowCustomCondition(Func<TRuleType, bool> condition, string description, string failDescription);
+
+        TReturnType OnlyDependOn();
+        TReturnType OnlyDependOn(params IType[] types);
+        TReturnType OnlyDependOn(params Type[] types);
         TReturnType OnlyDependOn(IObjectProvider<IType> types);
         TReturnType OnlyDependOn(IEnumerable<IType> types);
         TReturnType OnlyDependOn(IEnumerable<Type> types);
 
-        TReturnType HaveAnyAttributes(Attribute firstAttribute, params Attribute[] moreAttributes);
-        TReturnType HaveAnyAttributes(Type firstAttribute, params Type[] moreAttributes);
+        TReturnType HaveAnyAttributes();
+        TReturnType HaveAnyAttributes(params Attribute[] attributes);
+        TReturnType HaveAnyAttributes(params Type[] attributes);
         TReturnType HaveAnyAttributes(IObjectProvider<Attribute> attributes);
         TReturnType HaveAnyAttributes(IEnumerable<Attribute> attributes);
         TReturnType HaveAnyAttributes(IEnumerable<Type> attributes);
 
-        TReturnType OnlyHaveAttributes(Attribute firstAttribute, params Attribute[] moreAttributes);
-        TReturnType OnlyHaveAttributes(Type firstAttribute, params Type[] moreAttributes);
+        TReturnType OnlyHaveAttributes();
+        TReturnType OnlyHaveAttributes(params Attribute[] attributes);
+        TReturnType OnlyHaveAttributes(params Type[] attributes);
         TReturnType OnlyHaveAttributes(IObjectProvider<Attribute> attributes);
         TReturnType OnlyHaveAttributes(IEnumerable<Attribute> attributes);
         TReturnType OnlyHaveAttributes(IEnumerable<Type> attributes);
+
         TReturnType HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);
-        TReturnType HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-
-        TReturnType HaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        );
-        TReturnType HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
+        TReturnType HaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
+        TReturnType HaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues);
         TReturnType HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);
-        TReturnType HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType HaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-
-        TReturnType HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-        TReturnType HaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
+        TReturnType HaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
+        TReturnType HaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+
+        TReturnType HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType HaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+        TReturnType HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType HaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
 
         TReturnType HaveName(string name);
         TReturnType HaveNameMatching(string pattern);
-
-        TReturnType HaveFullName(string fullName);
-        TReturnType HaveFullNameMatching(string pattern);
         TReturnType HaveNameStartingWith(string pattern);
         TReturnType HaveNameEndingWith(string pattern);
         TReturnType HaveNameContaining(string pattern);
+
+        TReturnType HaveFullName(string fullName);
+        TReturnType HaveFullNameMatching(string pattern);
+        TReturnType HaveFullNameStartingWith(string pattern);
+        TReturnType HaveFullNameEndingWith(string pattern);
         TReturnType HaveFullNameContaining(string pattern);
+
+        TReturnType HaveAssemblyQualifiedName(string assemblyQualifiedName);
+        TReturnType HaveAssemblyQualifiedNameMatching(string pattern);
+        TReturnType HaveAssemblyQualifiedNameStartingWith(string pattern);
+        TReturnType HaveAssemblyQualifiedNameEndingWith(string pattern);
+        TReturnType HaveAssemblyQualifiedNameContaining(string pattern);
+
         TReturnType BePrivate();
         TReturnType BePublic();
         TReturnType BeProtected();
@@ -120,91 +98,70 @@ TReturnType HaveAttributeWithNamedArguments(
 
         TReturnType NotExist();
 
-        TReturnType NotBe(ICanBeAnalyzed firstObject, params ICanBeAnalyzed[] moreObjects);
+        TReturnType NotBe(params ICanBeAnalyzed[] objects);
         TReturnType NotBe(IEnumerable<ICanBeAnalyzed> objects);
         TReturnType NotBe(IObjectProvider<ICanBeAnalyzed> objects);
 
-        TReturnType NotCallAny(MethodMember method, params MethodMember[] moreMethods);
+        TReturnType NotCallAny(params MethodMember[] methods);
         TReturnType NotCallAny(IEnumerable<MethodMember> methods);
         TReturnType NotCallAny(IObjectProvider<MethodMember> methods);
 
-        TReturnType NotDependOnAny(IType firstType, params IType[] moreTypes);
-        TReturnType NotDependOnAny(Type firstType, params Type[] moreTypes);
+        TReturnType NotDependOnAny();
+        TReturnType NotDependOnAny(params IType[] types);
+        TReturnType NotDependOnAny(params Type[] types);
         TReturnType NotDependOnAny(IObjectProvider<IType> types);
         TReturnType NotDependOnAny(IEnumerable<IType> types);
         TReturnType NotDependOnAny(IEnumerable<Type> types);
 
-        TReturnType NotHaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        );
-        TReturnType NotHaveAnyAttributes(Type firstAttribute, params Type[] moreAttributes);
+        TReturnType NotHaveAnyAttributes();
+        TReturnType NotHaveAnyAttributes(params Attribute[] attributes);
+        TReturnType NotHaveAnyAttributes(params Type[] attributes);
         TReturnType NotHaveAnyAttributes(IObjectProvider<Attribute> attributes);
         TReturnType NotHaveAnyAttributes(IEnumerable<Attribute> attributes);
         TReturnType NotHaveAnyAttributes(IEnumerable<Type> attributes);
+
         TReturnType NotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);
-        TReturnType NotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType NotHaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        );
-        TReturnType NotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType NotHaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        );
-        TReturnType NotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType NotHaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType NotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-        TReturnType NotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType NotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-        TReturnType NotHaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType NotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
+        TReturnType NotHaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType NotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
+        TReturnType NotHaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues);
+        TReturnType NotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);
+        TReturnType NotHaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType NotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
+
+        TReturnType NotHaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+
+        TReturnType NotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType NotHaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+        TReturnType NotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType NotHaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
 
         TReturnType NotHaveName(string name);
         TReturnType NotHaveNameMatching(string pattern);
-
-        TReturnType NotHaveFullName(string fullName);
-        TReturnType NotHaveFullNameMatching(string pattern);
         TReturnType NotHaveNameStartingWith(string pattern);
         TReturnType NotHaveNameEndingWith(string pattern);
         TReturnType NotHaveNameContaining(string pattern);
+
+        TReturnType NotHaveFullName(string fullName);
+        TReturnType NotHaveFullNameMatching(string pattern);
+        TReturnType NotHaveFullNameStartingWith(string pattern);
+        TReturnType NotHaveFullNameEndingWith(string pattern);
         TReturnType NotHaveFullNameContaining(string pattern);
+
+        TReturnType NotHaveAssemblyQualifiedName(string assemblyQualifiedName);
+        TReturnType NotHaveAssemblyQualifiedNameMatching(string pattern);
+        TReturnType NotHaveAssemblyQualifiedNameStartingWith(string pattern);
+        TReturnType NotHaveAssemblyQualifiedNameEndingWith(string pattern);
+        TReturnType NotHaveAssemblyQualifiedNameContaining(string pattern);
+
         TReturnType NotBePrivate();
         TReturnType NotBePublic();
         TReturnType NotBeProtected();
         TReturnType NotBeInternal();
         TReturnType NotBeProtectedInternal();
         TReturnType NotBePrivateProtected();
+
+        // csharpier-ignore-end
     }
 }
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/IObjectPredicates.cs b/ArchUnitNET/Fluent/Syntax/Elements/IObjectPredicates.cs
index 53e6e43d1..600ded7b9 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/IObjectPredicates.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/IObjectPredicates.cs
@@ -9,96 +9,81 @@ namespace ArchUnitNET.Fluent.Syntax.Elements
     public interface IObjectPredicates<out TReturnType, TRuleType>
         where TRuleType : ICanBeAnalyzed
     {
-        TReturnType Are(ICanBeAnalyzed firstObject, params ICanBeAnalyzed[] moreObjects);
+        // csharpier-ignore-start
+
+        TReturnType FollowCustomPredicate(IPredicate<TRuleType> predicate);
+        TReturnType FollowCustomPredicate(Func<TRuleType, bool> predicate, string description);
+
+        TReturnType Are(params ICanBeAnalyzed[] objects);
         TReturnType Are(IEnumerable<ICanBeAnalyzed> objects);
         TReturnType Are(IObjectProvider<ICanBeAnalyzed> objects);
 
-        TReturnType CallAny(MethodMember method, params MethodMember[] moreMethods);
+        TReturnType CallAny(params MethodMember[] methods);
         TReturnType CallAny(IEnumerable<MethodMember> methods);
         TReturnType CallAny(IObjectProvider<MethodMember> methods);
 
-        TReturnType DependOnAny(Type firstType, params Type[] moreTypes);
-        TReturnType DependOnAny(IType firstType, params IType[] moreTypes);
-        TReturnType DependOnAny(IObjectProvider<IType> types);
+        TReturnType DependOnAny();
+        TReturnType DependOnAny(params IType[] types);
+        TReturnType DependOnAny(params Type[] types);
         TReturnType DependOnAny(IEnumerable<IType> types);
         TReturnType DependOnAny(IEnumerable<Type> types);
-        TReturnType FollowCustomPredicate(IPredicate<TRuleType> predicate);
-        TReturnType FollowCustomPredicate(Func<TRuleType, bool> predicate, string description);
+        TReturnType DependOnAny(IObjectProvider<IType> types);
 
-        TReturnType OnlyDependOn(Type firstType, params Type[] moreTypes);
-        TReturnType OnlyDependOn(IType firstType, params IType[] moreTypes);
-        TReturnType OnlyDependOn(IObjectProvider<IType> types);
+        TReturnType OnlyDependOn();
+        TReturnType OnlyDependOn(params IType[] types);
+        TReturnType OnlyDependOn(params Type[] types);
         TReturnType OnlyDependOn(IEnumerable<IType> types);
         TReturnType OnlyDependOn(IEnumerable<Type> types);
+        TReturnType OnlyDependOn(IObjectProvider<IType> types);
 
-        TReturnType HaveAnyAttributes(Attribute firstAttribute, params Attribute[] moreAttributes);
-        TReturnType HaveAnyAttributes(Type firstAttribute, params Type[] moreAttributes);
-        TReturnType HaveAnyAttributes(IObjectProvider<Attribute> attributes);
+        TReturnType HaveAnyAttributes();
+        TReturnType HaveAnyAttributes(params Attribute[] attributes);
+        TReturnType HaveAnyAttributes(params Type[] attributes);
         TReturnType HaveAnyAttributes(IEnumerable<Attribute> attributes);
         TReturnType HaveAnyAttributes(IEnumerable<Type> attributes);
+        TReturnType HaveAnyAttributes(IObjectProvider<Attribute> attributes);
 
-        TReturnType OnlyHaveAttributes(Attribute firstAttribute, params Attribute[] moreAttributes);
-        TReturnType OnlyHaveAttributes(Type firstAttribute, params Type[] moreAttributes);
-        TReturnType OnlyHaveAttributes(IObjectProvider<Attribute> attributes);
+        TReturnType OnlyHaveAttributes();
+        TReturnType OnlyHaveAttributes(params Attribute[] attributes);
+        TReturnType OnlyHaveAttributes(params Type[] attributes);
         TReturnType OnlyHaveAttributes(IEnumerable<Attribute> attributes);
         TReturnType OnlyHaveAttributes(IEnumerable<Type> attributes);
+        TReturnType OnlyHaveAttributes(IObjectProvider<Attribute> attributes);
+
         TReturnType HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);
-        TReturnType HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-
-        TReturnType HaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        );
-        TReturnType HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
+        TReturnType HaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
+        TReturnType HaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues);
         TReturnType HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);
-        TReturnType HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType HaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-
-        TReturnType HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-        TReturnType HaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
+        TReturnType HaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
+        TReturnType HaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+
+        TReturnType HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType HaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+        TReturnType HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType HaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
 
         TReturnType HaveName(string name);
         TReturnType HaveNameMatching(string pattern);
-
-        TReturnType HaveFullName(string fullName);
-        TReturnType HaveFullNameMatching(string pattern);
         TReturnType HaveNameStartingWith(string pattern);
         TReturnType HaveNameEndingWith(string pattern);
         TReturnType HaveNameContaining(string pattern);
+
+        TReturnType HaveFullName(string fullName);
+        TReturnType HaveFullNameMatching(string pattern);
+        TReturnType HaveFullNameStartingWith(string pattern);
+        TReturnType HaveFullNameEndingWith(string pattern);
         TReturnType HaveFullNameContaining(string pattern);
+
+        TReturnType HaveAssemblyQualifiedName(string assemblyQualifiedName);
+        TReturnType HaveAssemblyQualifiedNameMatching(string pattern);
+        TReturnType HaveAssemblyQualifiedNameStartingWith(string pattern);
+        TReturnType HaveAssemblyQualifiedNameEndingWith(string pattern);
+        TReturnType HaveAssemblyQualifiedNameContaining(string pattern);
+
         TReturnType ArePrivate();
         TReturnType ArePublic();
         TReturnType AreProtected();
@@ -108,93 +93,69 @@ TReturnType HaveAttributeWithNamedArguments(
 
         //Negations
 
-        TReturnType AreNot(ICanBeAnalyzed firstObject, params ICanBeAnalyzed[] moreObjects);
+        TReturnType AreNot(params ICanBeAnalyzed[] objects);
         TReturnType AreNot(IEnumerable<ICanBeAnalyzed> objects);
         TReturnType AreNot(IObjectProvider<ICanBeAnalyzed> objects);
 
-        TReturnType DoNotCallAny(MethodMember method, params MethodMember[] moreMethods);
+        TReturnType DoNotCallAny(params MethodMember[] methods);
         TReturnType DoNotCallAny(IEnumerable<MethodMember> methods);
         TReturnType DoNotCallAny(IObjectProvider<MethodMember> methods);
 
-        TReturnType DoNotDependOnAny(Type firstType, params Type[] moreTypes);
-        TReturnType DoNotDependOnAny(IType firstType, params IType[] moreTypes);
+        TReturnType DoNotDependOnAny();
+        TReturnType DoNotDependOnAny(params IType[] types);
+        TReturnType DoNotDependOnAny(params Type[] types);
         TReturnType DoNotDependOnAny(IObjectProvider<IType> types);
         TReturnType DoNotDependOnAny(IEnumerable<IType> types);
         TReturnType DoNotDependOnAny(IEnumerable<Type> types);
 
-        TReturnType DoNotHaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        );
-        TReturnType DoNotHaveAnyAttributes(Type firstAttribute, params Type[] moreAttributes);
+        TReturnType DoNotHaveAnyAttributes();
+        TReturnType DoNotHaveAnyAttributes(params Attribute[] attributes);
+        TReturnType DoNotHaveAnyAttributes(params Type[] attributes);
         TReturnType DoNotHaveAnyAttributes(IObjectProvider<Attribute> attributes);
         TReturnType DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes);
         TReturnType DoNotHaveAnyAttributes(IEnumerable<Type> attributes);
+
         TReturnType DoNotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);
-        TReturnType DoNotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-
-        TReturnType DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        );
-        TReturnType DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType DoNotHaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        );
-        TReturnType DoNotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        );
-        TReturnType DoNotHaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType DoNotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-
-        TReturnType DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
-        TReturnType DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        );
-        TReturnType DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        );
+        TReturnType DoNotHaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType DoNotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
+        TReturnType DoNotHaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues);
+        TReturnType DoNotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);
+        TReturnType DoNotHaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues);
+
+        TReturnType DoNotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
+        TReturnType DoNotHaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+
+        TReturnType DoNotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType DoNotHaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
+        TReturnType DoNotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
+        TReturnType DoNotHaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments);
 
         TReturnType DoNotHaveName(string name);
         TReturnType DoNotHaveNameMatching(string pattern);
-
-        TReturnType DoNotHaveFullName(string fullName);
-        TReturnType DoNotHaveFullNameMatching(string pattern);
         TReturnType DoNotHaveNameStartingWith(string pattern);
         TReturnType DoNotHaveNameEndingWith(string pattern);
         TReturnType DoNotHaveNameContaining(string pattern);
+
+        TReturnType DoNotHaveFullName(string fullName);
+        TReturnType DoNotHaveFullNameMatching(string pattern);
+        TReturnType DoNotHaveFullNameStartingWith(string pattern);
+        TReturnType DoNotHaveFullNameEndingWith(string pattern);
         TReturnType DoNotHaveFullNameContaining(string pattern);
+
+        TReturnType DoNotHaveAssemblyQualifiedName(string assemblyQualifiedName);
+        TReturnType DoNotHaveAssemblyQualifiedNameMatching(string pattern);
+        TReturnType DoNotHaveAssemblyQualifiedNameStartingWith(string pattern);
+        TReturnType DoNotHaveAssemblyQualifiedNameEndingWith(string pattern);
+        TReturnType DoNotHaveAssemblyQualifiedNameContaining(string pattern);
+
         TReturnType AreNotPrivate();
         TReturnType AreNotPublic();
         TReturnType AreNotProtected();
         TReturnType AreNotInternal();
         TReturnType AreNotProtectedInternal();
         TReturnType AreNotPrivateProtected();
+
+        // csharpier-ignore-end
     }
 }
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs
index 99f8bf2e6..d9f3082b2 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs
@@ -47,12 +47,8 @@ Architecture architecture
                 }
             }
 
-            return new ArchitectureCondition<TRuleType>(
-                Condition,
-                (sizedObjectProvider != null && sizedObjectProvider.Count == 0)
-                    ? "not exist"
-                    : "be " + objectProvider.Description
-            );
+            var description = objectProvider.FormatDescription("not exist", "be", "be");
+            return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
         public static ICondition<TRuleType> CallAny(IObjectProvider<MethodMember> objectProvider)
@@ -69,16 +65,15 @@ Architecture architecture
                     .ToList();
                 foreach (var failedObject in typeList.Except(passedObjects))
                 {
-                    var dynamicFailDescription = "does call";
-                    var first = true;
-                    foreach (var method in failedObject.GetCalledMethods().Except(methodList))
-                    {
-                        dynamicFailDescription += first
-                            ? " " + method.FullName
-                            : " and " + method.FullName;
-                        first = false;
-                    }
-
+                    var calledMethods = failedObject.GetCalledMethods().ToList();
+                    var dynamicFailDescription =
+                        calledMethods.Count == 0
+                            ? "does not call any methods"
+                            : "only calls "
+                                + string.Join(
+                                    " and ",
+                                    calledMethods.Select(method => $"\"{method.FullName}\"")
+                                );
                     yield return new ConditionResult(failedObject, false, dynamicFailDescription);
                 }
                 foreach (var passedObject in passedObjects)
@@ -86,11 +81,11 @@ Architecture architecture
                     yield return new ConditionResult(passedObject, true);
                 }
             }
-
-            var description =
-                (objectProvider as ISizedObjectProvider<MethodMember>)?.Count == 0
-                    ? "call any of no methods (impossible)"
-                    : "call any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "call any of no methods (impossible)",
+                "call",
+                "call any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
@@ -108,29 +103,27 @@ Architecture architecture
                     .ToList();
                 foreach (var failedObject in ruleTypeList.Except(passedObjects))
                 {
-                    var dynamicFailDescription = "does depend on";
-                    var first = true;
-                    foreach (var type in failedObject.GetTypeDependencies().Except(typeList))
-                    {
-                        dynamicFailDescription += first
-                            ? " " + type.FullName
-                            : " and " + type.FullName;
-                        first = false;
-                    }
-
+                    var dependants = failedObject.GetTypeDependencies(architecture).ToList();
+                    var dynamicFailDescription =
+                        dependants.Count == 0
+                            ? "does not depend on any type"
+                            : "only depends on "
+                                + string.Join(
+                                    " and ",
+                                    dependants.Select(type => $"\"{type.FullName}\"")
+                                );
                     yield return new ConditionResult(failedObject, false, dynamicFailDescription);
                 }
-
                 foreach (var passedObject in passedObjects)
                 {
                     yield return new ConditionResult(passedObject, true);
                 }
             }
-
-            var description =
-                (objectProvider as ISizedObjectProvider<IType>)?.Count == 0
-                    ? "depend on any of no types (impossible)"
-                    : "depend on any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "depend on any of no types (impossible)",
+                "depend on",
+                "depend on any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
@@ -184,10 +177,11 @@ Architecture architecture
                 }
             }
 
-            var description =
-                (objectProvider as ISizedObjectProvider<IType>)?.Count == 0
-                    ? "have no dependencies"
-                    : "only depend on " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "have no dependencies",
+                "only depend on",
+                "only depend on"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
@@ -195,7 +189,6 @@ public static ICondition<TRuleType> HaveAnyAttributes(
             IObjectProvider<Attribute> objectProvider
         )
         {
-            var sizedObjectProvider = objectProvider as ISizedObjectProvider<Attribute>;
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
                 Architecture architecture
@@ -208,13 +201,16 @@ Architecture architecture
                     .ToList();
                 foreach (var failedObject in ruleTypeList.Except(passedObjects))
                 {
-                    yield return new ConditionResult(
-                        failedObject,
-                        false,
-                        (sizedObjectProvider != null && sizedObjectProvider.Count == 0)
-                            ? "does not have any of no attributes (always true)"
-                            : "does not have any " + objectProvider.Description
-                    );
+                    var attributes = failedObject.Attributes.ToList();
+                    var failDescription =
+                        attributes.Count == 0
+                            ? "does not have any attributes"
+                            : "only has attributes "
+                                + string.Join(
+                                    " and ",
+                                    attributes.Select(attribute => $"\"{attribute.FullName}\"")
+                                );
+                    yield return new ConditionResult(failedObject, false, failDescription);
                 }
 
                 foreach (var passedObject in passedObjects)
@@ -223,10 +219,11 @@ Architecture architecture
                 }
             }
 
-            var description =
-                (sizedObjectProvider != null && sizedObjectProvider.Count == 0)
-                    ? "have one of no attributes (impossible)"
-                    : "have any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "have any of no attributes (impossible)",
+                "have",
+                "have any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
@@ -265,77 +262,14 @@ Architecture architecture
                 }
             }
 
-            var description =
-                (objectProvider as ISizedObjectProvider<Attribute>)?.Count == 0
-                    ? "have no attributes"
-                    : "does only have " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "have no attributes",
+                "only have",
+                "only have any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return HaveAnyAttributesWithArguments(argumentValues);
-        }
-
-        public static ICondition<TRuleType> HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return HaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static ICondition<TRuleType> HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return HaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static ICondition<TRuleType> HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return HaveAnyAttributesWithNamedArguments(attributeArguments);
-        }
-
-        public static ICondition<TRuleType> HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return HaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
-        public static ICondition<TRuleType> HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return HaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
         public static ICondition<TRuleType> HaveAnyAttributesWithArguments(
             IEnumerable<object> argumentValues
         )
@@ -889,6 +823,33 @@ public static ICondition<TRuleType> HaveNameMatching(string pattern)
             );
         }
 
+        public static ICondition<TRuleType> HaveNameStartingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.NameStartsWith(pattern),
+                obj => "does have name " + obj.Name,
+                "have name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> HaveNameEndingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.NameEndsWith(pattern),
+                obj => "does have name " + obj.Name,
+                "have name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> HaveNameContaining(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.NameContains(pattern),
+                obj => "does have name " + obj.Name,
+                "have name containing \"" + pattern + "\""
+            );
+        }
+
         public static ICondition<TRuleType> HaveFullName(string name)
         {
             return new SimpleCondition<TRuleType>(
@@ -907,39 +868,75 @@ public static ICondition<TRuleType> HaveFullNameMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveNameStartingWith(string pattern)
+        public static ICondition<TRuleType> HaveFullNameStartingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
-                obj => obj.NameStartsWith(pattern),
-                obj => "does have name " + obj.Name,
-                "have name starting with \"" + pattern + "\""
+                obj => obj.FullNameStartsWith(pattern),
+                obj => "does have full name " + obj.FullName,
+                "have full name starting with \"" + pattern + "\""
             );
         }
 
-        public static ICondition<TRuleType> HaveNameEndingWith(string pattern)
+        public static ICondition<TRuleType> HaveFullNameEndingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
-                obj => obj.NameEndsWith(pattern),
-                obj => "does have name " + obj.Name,
-                "have name ending with \"" + pattern + "\""
+                obj => obj.FullNameEndsWith(pattern),
+                obj => "does have full name " + obj.FullName,
+                "have full name ending with \"" + pattern + "\""
             );
         }
 
-        public static ICondition<TRuleType> HaveNameContaining(string pattern)
+        public static ICondition<TRuleType> HaveFullNameContaining(string pattern)
         {
             return new SimpleCondition<TRuleType>(
-                obj => obj.NameContains(pattern),
-                obj => "does have name " + obj.Name,
-                "have name containing \"" + pattern + "\""
+                obj => obj.FullNameContains(pattern),
+                obj => "does have full name " + obj.FullName,
+                "have full name containing \"" + pattern + "\""
             );
         }
 
-        public static ICondition<TRuleType> HaveFullNameContaining(string pattern)
+        public static ICondition<TRuleType> HaveAssemblyQualifiedName(string assemblyQualifiedName)
         {
             return new SimpleCondition<TRuleType>(
-                obj => obj.FullNameContains(pattern),
-                obj => "does have full name " + obj.FullName,
-                "have full name containing \"" + pattern + "\""
+                obj => obj.AssemblyQualifiedNameEquals(assemblyQualifiedName),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "have assembly qualified name \"" + assemblyQualifiedName + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> HaveAssemblyQualifiedNameMatching(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.AssemblyQualifiedNameMatches(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "have assembly qualified name matching \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> HaveAssemblyQualifiedNameStartingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.AssemblyQualifiedNameStartsWith(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "have assembly qualified name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> HaveAssemblyQualifiedNameEndingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.AssemblyQualifiedNameEndsWith(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "have assembly qualified name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> HaveAssemblyQualifiedNameContaining(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => obj.AssemblyQualifiedNameContains(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "have assembly qualified name containing \"" + pattern + "\""
             );
         }
 
@@ -1067,12 +1064,12 @@ Architecture architecture
                 }
             }
 
-            return new ArchitectureCondition<TRuleType>(
-                Condition,
-                (objectProvider as ISizedObjectProvider<ICanBeAnalyzed>)?.Count == 0
-                    ? "exist"
-                    : "not be " + objectProvider.Description
+            var description = objectProvider.FormatDescription(
+                "not be any of no objects (always true)",
+                "not be",
+                "not be"
             );
+            return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
         public static ICondition<TRuleType> NotCallAny(IObjectProvider<MethodMember> objectProvider)
@@ -1089,29 +1086,24 @@ Architecture architecture
                     .ToList();
                 foreach (var failedObject in failedObjects)
                 {
-                    var dynamicFailDescription = "does call";
-                    var first = true;
-                    foreach (var method in failedObject.GetCalledMethods().Intersect(methodList))
-                    {
-                        dynamicFailDescription += first
-                            ? " " + method.FullName
-                            : " and " + method.FullName;
-                        first = false;
-                    }
-
+                    var calledMethods = failedObject
+                        .GetCalledMethods()
+                        .Intersect(methodList)
+                        .Select(method => $"\"{method.FullName}\"");
+                    var dynamicFailDescription = "does call " + string.Join(" and ", calledMethods);
                     yield return new ConditionResult(failedObject, false, dynamicFailDescription);
                 }
-
                 foreach (var passedObject in typeList.Except(failedObjects))
                 {
                     yield return new ConditionResult(passedObject, true);
                 }
             }
 
-            var description =
-                (objectProvider as ISizedObjectProvider<MethodMember>)?.Count == 0
-                    ? "not call any of no methods (always true)"
-                    : "not call any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "not call any of no methods (always true)",
+                "not call",
+                "not call any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
@@ -1129,29 +1121,25 @@ Architecture architecture
                     .ToList();
                 foreach (var failedObject in failedObjects)
                 {
-                    var dynamicFailDescription = "does depend on";
-                    var first = true;
-                    foreach (var type in failedObject.GetTypeDependencies().Intersect(typeList))
-                    {
-                        dynamicFailDescription += first
-                            ? " " + type.FullName
-                            : " and " + type.FullName;
-                        first = false;
-                    }
-
+                    var dependants = failedObject
+                        .GetTypeDependencies()
+                        .Intersect(typeList)
+                        .Select(type => $"\"{type.FullName}\"");
+                    var dynamicFailDescription =
+                        "does depend on " + string.Join(" and ", dependants);
                     yield return new ConditionResult(failedObject, false, dynamicFailDescription);
                 }
-
                 foreach (var passedObject in ruleTypeList.Except(failedObjects))
                 {
                     yield return new ConditionResult(passedObject, true);
                 }
             }
 
-            var description =
-                (objectProvider as ISizedObjectProvider<IType>)?.Count == 0
-                    ? "not depend on any of no types (always true)"
-                    : "not depend on any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "not depend on any of no types (always true)",
+                "not depend on",
+                "not depend on any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
@@ -1190,77 +1178,14 @@ Architecture architecture
                 }
             }
 
-            var description =
-                (objectProvider as ISizedObjectProvider<Attribute>)?.Count == 0
-                    ? "not have any of no attributes (always true)"
-                    : "not have any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "not have any of no attributes (always true)",
+                "not have",
+                "not have any"
+            );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return NotHaveAnyAttributesWithArguments(argumentValues);
-        }
-
-        public static ICondition<TRuleType> NotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return NotHaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static ICondition<TRuleType> NotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return NotHaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static ICondition<TRuleType> NotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return NotHaveAnyAttributesWithNamedArguments(attributeArguments);
-        }
-
-        public static ICondition<TRuleType> NotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return NotHaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
-        public static ICondition<TRuleType> NotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return NotHaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
         public static ICondition<TRuleType> NotHaveAnyAttributesWithArguments(
             IEnumerable<object> argumentValues
         )
@@ -1816,6 +1741,33 @@ public static ICondition<TRuleType> NotHaveNameMatching(string pattern)
             );
         }
 
+        public static ICondition<TRuleType> NotHaveNameStartingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.NameStartsWith(pattern),
+                obj => "does have name " + obj.Name,
+                "not have name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> NotHaveNameEndingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.NameEndsWith(pattern),
+                obj => "does have name " + obj.Name,
+                "not have name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> NotHaveNameContaining(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.NameContains(pattern),
+                obj => "does have name " + obj.Name,
+                "not have name containing \"" + pattern + "\""
+            );
+        }
+
         public static ICondition<TRuleType> NotHaveFullName(string fullName)
         {
             return new SimpleCondition<TRuleType>(
@@ -1834,39 +1786,77 @@ public static ICondition<TRuleType> NotHaveFullNameMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameStartingWith(string pattern)
+        public static ICondition<TRuleType> NotHaveFullNameStartingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
-                obj => !obj.NameStartsWith(pattern),
-                obj => "does have name " + obj.Name,
-                "not have name starting with \"" + pattern + "\""
+                obj => !obj.FullNameStartsWith(pattern),
+                obj => "does have full name " + obj.FullName,
+                "not have full name starting with \"" + pattern + "\""
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameEndingWith(string pattern)
+        public static ICondition<TRuleType> NotHaveFullNameEndingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
-                obj => !obj.NameEndsWith(pattern),
-                obj => "does have name " + obj.Name,
-                "not have name ending with \"" + pattern + "\""
+                obj => !obj.FullNameEndsWith(pattern),
+                obj => "does have full name " + obj.FullName,
+                "not have full name ending with \"" + pattern + "\""
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameContaining(string pattern)
+        public static ICondition<TRuleType> NotHaveFullNameContaining(string pattern)
         {
             return new SimpleCondition<TRuleType>(
-                obj => !obj.NameContains(pattern),
-                obj => "does have name " + obj.Name,
-                "not have name containing \"" + pattern + "\""
+                obj => !obj.FullNameContains(pattern),
+                obj => "does have full name " + obj.FullName,
+                "not have full name containing \"" + pattern + "\""
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFullNameContaining(string pattern)
+        public static ICondition<TRuleType> NotHaveAssemblyQualifiedName(
+            string assemblyQualifiedName
+        )
         {
             return new SimpleCondition<TRuleType>(
-                obj => !obj.FullNameContains(pattern),
-                obj => "does have full name " + obj.FullName,
-                "not have full name containing \"" + pattern + "\""
+                obj => !obj.AssemblyQualifiedNameEquals(assemblyQualifiedName),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "not have assembly qualified name \"" + assemblyQualifiedName + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameMatching(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.AssemblyQualifiedNameMatches(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "not have assembly qualified name matching \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameStartingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.AssemblyQualifiedNameStartsWith(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "not have assembly qualified name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameEndingWith(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.AssemblyQualifiedNameEndsWith(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "not have assembly qualified name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameContaining(string pattern)
+        {
+            return new SimpleCondition<TRuleType>(
+                obj => !obj.AssemblyQualifiedNameContains(pattern),
+                obj => "does have assembly qualified name " + obj.AssemblyQualifiedName,
+                "not have assembly qualified name containing \"" + pattern + "\""
             );
         }
 
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/ObjectPredicatesDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/ObjectPredicatesDefinition.cs
index 5103207be..40e0fc242 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/ObjectPredicatesDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/ObjectPredicatesDefinition.cs
@@ -14,47 +14,6 @@ namespace ArchUnitNET.Fluent.Syntax.Elements
     public static class ObjectPredicatesDefinition<T>
         where T : ICanBeAnalyzed
     {
-        public static IPredicate<T> Are(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            var objects = new List<ICanBeAnalyzed> { firstObject }
-                .Union(moreObjects)
-                .OfType<T>();
-            var description = moreObjects.Aggregate(
-                "are \"" + firstObject.FullName + "\"",
-                (current, obj) => current + " or \"" + obj.FullName + "\""
-            );
-            return new EnumerablePredicate<T>(e => e.Intersect(objects), description);
-        }
-
-        public static IPredicate<T> Are(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            var objectList = objects.ToList();
-            string description;
-            if (objectList.IsNullOrEmpty())
-            {
-                description = "do not exist (always empty)";
-            }
-            else
-            {
-                var firstObject = objectList.First();
-                description = objectList
-                    .Where(obj => !obj.Equals(firstObject))
-                    .Distinct()
-                    .Aggregate(
-                        "are \"" + firstObject.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(
-                e => e.Intersect(objectList.OfType<T>()),
-                description
-            );
-        }
-
         public static IPredicate<T> Are(IObjectProvider<ICanBeAnalyzed> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
@@ -62,14 +21,12 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Intersect(objectProvider.GetObjects(architecture).OfType<T>());
             }
 
-            return new ArchitecturePredicate<T>(Filter, "are " + objectProvider.Description);
-        }
-
-        public static IPredicate<T> CallAny(MethodMember method, params MethodMember[] moreMethods)
-        {
-            var methods = new List<MethodMember> { method };
-            methods.AddRange(moreMethods);
-            return CallAny(methods);
+            var description = objectProvider.FormatDescription(
+                "are any of no objects (always empty)",
+                "are",
+                "are"
+            );
+            return new ArchitecturePredicate<T>(Filter, description);
         }
 
         public static IPredicate<T> CallAny(IObjectProvider<MethodMember> objectProvider)
@@ -80,53 +37,14 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Where(obj => obj.GetCalledMethods().Intersect(methods).Any());
             }
 
-            var description = "call any " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "do not call any method",
+                "call",
+                "call any"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> CallAny(IEnumerable<MethodMember> methods)
-        {
-            var methodList = methods.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => obj.GetCalledMethods().Intersect(methodList).Any());
-            }
-
-            string description;
-            if (methodList.IsNullOrEmpty())
-            {
-                description = "call one of no methods (impossible)";
-            }
-            else
-            {
-                var firstMethod = methodList.First();
-                description = methodList
-                    .Where(obj => !obj.Equals(firstMethod))
-                    .Distinct()
-                    .Aggregate(
-                        "call \"" + firstMethod.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            var types = new List<IType> { firstType };
-            types.AddRange(moreTypes);
-            return DependOnAny(types);
-        }
-
-        public static IPredicate<T> DependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            var types = new List<Type> { firstType };
-            types.AddRange(moreTypes);
-            return DependOnAny(types);
-        }
-
         public static IPredicate<T> DependOnAny(IObjectProvider<IType> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
@@ -135,81 +53,11 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Where(obj => obj.GetTypeDependencies().Intersect(types).Any());
             }
 
-            var description = "depend on any " + objectProvider.Description;
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DependOnAny(IEnumerable<IType> types)
-        {
-            var typeList = types.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => obj.GetTypeDependencies().Intersect(typeList).Any());
-            }
-
-            string description;
-            if (typeList.IsNullOrEmpty())
-            {
-                description = "have no dependencies";
-            }
-            else
-            {
-                var firstType = typeList.First();
-                description = typeList
-                    .Where(obj => !obj.Equals(firstType))
-                    .Distinct()
-                    .Aggregate(
-                        "depend on \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DependOnAny(IEnumerable<Type> types)
-        {
-            var typeList = types.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                var archUnitTypeList = new List<IType>();
-                foreach (var type in typeList)
-                {
-                    try
-                    {
-                        var archUnitType = architecture.GetITypeOfType(type);
-                        archUnitTypeList.Add(archUnitType);
-                    }
-                    catch (TypeDoesNotExistInArchitecture)
-                    {
-                        //ignore, can't have a dependency anyways
-                    }
-                }
-
-                return objects.Where(obj =>
-                    obj.GetTypeDependencies().Intersect(archUnitTypeList).Any()
-                );
-            }
-
-            string description;
-            if (typeList.IsNullOrEmpty())
-            {
-                description = "have no dependencies";
-            }
-            else
-            {
-                var firstType = typeList.First();
-                description = typeList
-                    .Where(obj => obj != firstType)
-                    .Distinct()
-                    .Aggregate(
-                        "depend on \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
+            var description = objectProvider.FormatDescription(
+                "depend on any of no types (impossible)",
+                "depend on",
+                "depend on any"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
@@ -221,20 +69,6 @@ string description
             return new SimplePredicate<T>(predicate, description);
         }
 
-        public static IPredicate<T> OnlyDependOn(IType firstType, params IType[] moreTypes)
-        {
-            var types = new List<IType> { firstType };
-            types.AddRange(moreTypes);
-            return OnlyDependOn(types);
-        }
-
-        public static IPredicate<T> OnlyDependOn(Type firstType, params Type[] moreTypes)
-        {
-            var types = new List<Type> { firstType };
-            types.AddRange(moreTypes);
-            return OnlyDependOn(types);
-        }
-
         public static IPredicate<T> OnlyDependOn(IObjectProvider<IType> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
@@ -245,106 +79,14 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 );
             }
 
-            var description = "only depend on " + objectProvider.Description;
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> OnlyDependOn(IEnumerable<IType> types)
-        {
-            var typeList = types.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                return objects.Where(obj =>
-                    obj.GetTypeDependencies(architecture).Except(typeList).IsNullOrEmpty()
-                );
-            }
-
-            string description;
-            if (typeList.IsNullOrEmpty())
-            {
-                description = "have no dependencies";
-            }
-            else
-            {
-                var firstType = typeList.First();
-                description = typeList
-                    .Where(obj => !obj.Equals(firstType))
-                    .Distinct()
-                    .Aggregate(
-                        "only depend on \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> OnlyDependOn(IEnumerable<Type> types)
-        {
-            var typeList = types.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                var archUnitTypeList = new List<IType>();
-                foreach (var type in typeList)
-                {
-                    try
-                    {
-                        var archUnitType = architecture.GetITypeOfType(type);
-                        archUnitTypeList.Add(archUnitType);
-                    }
-                    catch (TypeDoesNotExistInArchitecture)
-                    {
-                        //ignore, can't have a dependency anyways
-                    }
-                }
-
-                return objects.Where(obj =>
-                    obj.GetTypeDependencies(architecture).Except(archUnitTypeList).IsNullOrEmpty()
-                );
-            }
-
-            string description;
-            if (typeList.IsNullOrEmpty())
-            {
-                description = "have no dependencies";
-            }
-            else
-            {
-                var firstType = typeList.First();
-                description = typeList
-                    .Where(obj => obj != firstType)
-                    .Distinct()
-                    .Aggregate(
-                        "only depend on \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
+            var description = objectProvider.FormatDescription(
+                "depend on no types",
+                "only depend on",
+                "only depend on"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> HaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            var attributes = new List<Attribute> { firstAttribute };
-            attributes.AddRange(moreAttributes);
-            return HaveAnyAttributes(attributes);
-        }
-
-        public static IPredicate<T> HaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            var attributes = new List<Type> { firstAttribute };
-            attributes.AddRange(moreAttributes);
-            return HaveAnyAttributes(attributes);
-        }
-
         public static IPredicate<T> HaveAnyAttributes(IObjectProvider<Attribute> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
@@ -353,89 +95,14 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Where(obj => obj.Attributes.Intersect(attributes).Any());
             }
 
-            var description = "have any " + objectProvider.Description;
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> HaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            var attributeList = attributes.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => obj.Attributes.Intersect(attributeList).Any());
-            }
-
-            string description;
-            if (attributeList.IsNullOrEmpty())
-            {
-                description = "have one of no attributes (impossible)";
-            }
-            else
-            {
-                var firstAttribute = attributeList.First();
-                description = attributeList
-                    .Where(obj => !obj.Equals(firstAttribute))
-                    .Distinct()
-                    .Aggregate(
-                        "have attribute \"" + firstAttribute.FullName + "\"",
-                        (current, attribute) => current + " or \"" + attribute.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> HaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            var attributeList = attributes.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                var archAttributeList = attributeList.Select(architecture.GetAttributeOfType);
-                return objects.Where(obj => obj.Attributes.Intersect(archAttributeList).Any());
-            }
-
-            string description;
-            if (attributeList.IsNullOrEmpty())
-            {
-                description = "have one of no attributes (impossible)";
-            }
-            else
-            {
-                var firstType = attributeList.First();
-                description = attributeList
-                    .Where(obj => obj != firstType)
-                    .Distinct()
-                    .Aggregate(
-                        "have attribute \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
+            var description = objectProvider.FormatDescription(
+                "have any of no attributes (always empty)",
+                "have",
+                "have any"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> OnlyHaveAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            var attributes = new List<Attribute> { firstAttribute };
-            attributes.AddRange(moreAttributes);
-            return OnlyHaveAttributes(attributes);
-        }
-
-        public static IPredicate<T> OnlyHaveAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            var attributes = new List<Type> { firstAttribute };
-            attributes.AddRange(moreAttributes);
-            return OnlyHaveAttributes(attributes);
-        }
-
         public static IPredicate<T> OnlyHaveAttributes(IObjectProvider<Attribute> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
@@ -444,146 +111,14 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Where(obj => !obj.Attributes.Except(attributes).Any());
             }
 
-            var description = "only have " + objectProvider.Description;
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> OnlyHaveAttributes(IEnumerable<Attribute> attributes)
-        {
-            var attributeList = attributes.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => !obj.Attributes.Except(attributeList).Any());
-            }
-
-            string description;
-            if (attributeList.IsNullOrEmpty())
-            {
-                description = "have no attributes";
-            }
-            else
-            {
-                var firstAttribute = attributeList.First();
-                description = attributeList
-                    .Where(obj => !obj.Equals(firstAttribute))
-                    .Distinct()
-                    .Aggregate(
-                        "only have attribute \"" + firstAttribute.FullName + "\"",
-                        (current, attribute) => current + " or \"" + attribute.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> OnlyHaveAttributes(IEnumerable<Type> attributes)
-        {
-            var attributeList = attributes.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                var archUnitAttributeList = new List<Attribute>();
-                foreach (var type in attributeList)
-                {
-                    try
-                    {
-                        var archUnitAttribute = architecture.GetAttributeOfType(type);
-                        archUnitAttributeList.Add(archUnitAttribute);
-                    }
-                    catch (TypeDoesNotExistInArchitecture)
-                    {
-                        //ignore, can't have a dependency anyways
-                    }
-                }
-
-                return objects.Where(obj => !obj.Attributes.Except(archUnitAttributeList).Any());
-            }
-
-            string description;
-            if (attributeList.IsNullOrEmpty())
-            {
-                description = "have no attributes";
-            }
-            else
-            {
-                var firstType = attributeList.First();
-                description = attributeList
-                    .Where(obj => obj != firstType)
-                    .Distinct()
-                    .Aggregate(
-                        "only have attribute \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
+            var description = objectProvider.FormatDescription(
+                "have no attributes",
+                "only have",
+                "only have"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return HaveAnyAttributesWithArguments(argumentValues);
-        }
-
-        public static IPredicate<T> HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return HaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static IPredicate<T> HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return HaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static IPredicate<T> HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return HaveAnyAttributesWithNamedArguments(attributeArguments);
-        }
-
-        public static IPredicate<T> HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return HaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
-        public static IPredicate<T> HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return HaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
         public static IPredicate<T> HaveAnyAttributesWithArguments(
             IEnumerable<object> argumentValues
         )
@@ -1017,67 +552,123 @@ bool Predicate(T obj, Architecture architecture)
             return new ArchitecturePredicate<T>(Predicate, description);
         }
 
-        public static IPredicate<T> HaveName(string name)
+        public static IPredicate<T> HaveName(string name)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.NameEquals(name),
+                "have name \"" + name + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveNameMatching(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.NameMatches(pattern),
+                "have name matching \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveNameStartingWith(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.NameStartsWith(pattern),
+                "have name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveNameEndingWith(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.NameEndsWith(pattern),
+                "have name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveNameContaining(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.NameContains(pattern),
+                "have name containing \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveFullName(string fullName)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.FullNameEquals(fullName),
+                "have full name \"" + fullName + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveFullNameMatching(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => obj.FullNameMatches(pattern),
+                "have full name matching \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> HaveFullNameStartingWith(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.NameEquals(name),
-                "have name \"" + name + "\""
+                obj => obj.FullNameStartsWith(pattern),
+                "have full name starting with \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> HaveNameMatching(string pattern)
+        public static IPredicate<T> HaveFullNameEndingWith(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.NameMatches(pattern),
-                "have name matching \"" + pattern + "\""
+                obj => obj.FullNameEndsWith(pattern),
+                "have full name ending with \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> HaveFullName(string fullName)
+        public static IPredicate<T> HaveFullNameContaining(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.FullNameEquals(fullName),
-                "have full name \"" + fullName + "\""
+                obj => obj.FullNameContains(pattern),
+                "have full name containing \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> HaveFullNameMatching(string pattern)
+        public static IPredicate<T> HaveAssemblyQualifiedName(string assemblyQualifiedName)
         {
             return new SimplePredicate<T>(
-                obj => obj.FullNameMatches(pattern),
-                "have full name matching \"" + pattern + "\""
+                obj => obj.AssemblyQualifiedNameEquals(assemblyQualifiedName),
+                "have assembly qualified name \"" + assemblyQualifiedName + "\""
             );
         }
 
-        public static IPredicate<T> HaveNameStartingWith(string pattern)
+        public static IPredicate<T> HaveAssemblyQualifiedNameMatching(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.NameStartsWith(pattern),
-                "have name starting with \"" + pattern + "\""
+                obj => obj.AssemblyQualifiedNameMatches(pattern),
+                "have assembly qualified name matching \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> HaveNameEndingWith(string pattern)
+        public static IPredicate<T> HaveAssemblyQualifiedNameStartingWith(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.NameEndsWith(pattern),
-                "have name ending with \"" + pattern + "\""
+                obj => obj.AssemblyQualifiedNameStartsWith(pattern),
+                "have assembly qualified name starting with \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> HaveNameContaining(string pattern)
+        public static IPredicate<T> HaveAssemblyQualifiedNameEndingWith(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.NameContains(pattern),
-                "have name containing \"" + pattern + "\""
+                obj => obj.AssemblyQualifiedNameEndsWith(pattern),
+                "have assembly qualified name ending with \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> HaveFullNameContaining(string pattern)
+        public static IPredicate<T> HaveAssemblyQualifiedNameContaining(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => obj.FullNameContains(pattern),
-                "have full name containing \"" + pattern + "\""
+                obj => obj.AssemblyQualifiedNameContains(pattern),
+                "have assembly qualified name containing \"" + pattern + "\""
             );
         }
 
@@ -1119,44 +710,6 @@ public static IPredicate<T> ArePrivateProtected()
 
         //Negations
 
-        public static IPredicate<T> AreNot(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            var objects = new List<ICanBeAnalyzed> { firstObject }
-                .Concat(moreObjects)
-                .OfType<T>();
-            var description = moreObjects.Aggregate(
-                "are not \"" + firstObject.FullName + "\"",
-                (current, obj) => current + " or \"" + obj.FullName + "\""
-            );
-            return new EnumerablePredicate<T>(e => e.Except(objects), description);
-        }
-
-        public static IPredicate<T> AreNot(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            var objectList = objects.ToList();
-            string description;
-            if (objectList.IsNullOrEmpty())
-            {
-                description = "are not no object (always true)";
-            }
-            else
-            {
-                var firstObject = objectList.First();
-                description = objectList
-                    .Where(obj => !obj.Equals(firstObject))
-                    .Distinct()
-                    .Aggregate(
-                        "are not \"" + firstObject.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(e => e.Except(objectList.OfType<T>()), description);
-        }
-
         public static IPredicate<T> AreNot(IObjectProvider<ICanBeAnalyzed> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
@@ -1164,17 +717,12 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Except(objectProvider.GetObjects(architecture).OfType<T>());
             }
 
-            return new ArchitecturePredicate<T>(Filter, "are not " + objectProvider.Description);
-        }
-
-        public static IPredicate<T> DoNotCallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            var methods = new List<MethodMember> { method };
-            methods.AddRange(moreMethods);
-            return DoNotCallAny(methods);
+            var description = objectProvider.FormatDescription(
+                "are not any of no objects (always true)",
+                "are not",
+                "are not"
+            );
+            return new ArchitecturePredicate<T>(Filter, description);
         }
 
         public static IPredicate<T> DoNotCallAny(IObjectProvider<MethodMember> objectProvider)
@@ -1185,159 +733,32 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Where(obj => !obj.GetCalledMethods().Intersect(methods).Any());
             }
 
-            var description = "do not call " + objectProvider.Description;
+            var description = objectProvider.FormatDescription(
+                "do not call any of no methods (always true)",
+                "do not call",
+                "do not call any"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> DoNotCallAny(IEnumerable<MethodMember> methods)
-        {
-            var methodList = methods.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => !obj.GetCalledMethods().Intersect(methodList).Any());
-            }
-
-            string description;
-            if (methodList.IsNullOrEmpty())
-            {
-                description = "do not call one of no methods (always true)";
-            }
-            else
-            {
-                var firstMethod = methodList.First();
-                description = methodList
-                    .Where(obj => !obj.Equals(firstMethod))
-                    .Distinct()
-                    .Aggregate(
-                        "do not call \"" + firstMethod.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DoNotDependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            var types = new List<IType> { firstType };
-            types.AddRange(moreTypes);
-            return DoNotDependOnAny(types);
-        }
-
-        public static IPredicate<T> DoNotDependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            var types = new List<Type> { firstType };
-            types.AddRange(moreTypes);
-            return DoNotDependOnAny(types);
-        }
-
         public static IPredicate<T> DoNotDependOnAny(IObjectProvider<IType> objectProvider)
         {
             IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
             {
                 var types = objectProvider.GetObjects(architecture);
-                return objects.Where(obj => !obj.GetTypeDependencies().Intersect(types).Any());
-            }
-
-            var description = "do not depend on any " + objectProvider.Description;
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DoNotDependOnAny(IEnumerable<IType> types)
-        {
-            var typeList = types.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => !obj.GetTypeDependencies().Intersect(typeList).Any());
-            }
-
-            string description;
-            if (typeList.IsNullOrEmpty())
-            {
-                description = "do not depend on no types (always true)";
-            }
-            else
-            {
-                var firstType = typeList.First();
-                description = typeList
-                    .Where(obj => !obj.Equals(firstType))
-                    .Distinct()
-                    .Aggregate(
-                        "do not depend on \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DoNotDependOnAny(IEnumerable<Type> types)
-        {
-            var typeList = types.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                var archUnitTypeList = new List<IType>();
-                foreach (var type in typeList)
-                {
-                    try
-                    {
-                        var archUnitType = architecture.GetITypeOfType(type);
-                        archUnitTypeList.Add(archUnitType);
-                    }
-                    catch (TypeDoesNotExistInArchitecture)
-                    {
-                        //ignore, can't have a dependency anyways
-                    }
-                }
-
                 return objects.Where(obj =>
-                    !obj.GetTypeDependencies().Intersect(archUnitTypeList).Any()
+                    !obj.GetTypeDependencies(architecture).Intersect(types).Any()
                 );
             }
 
-            string description;
-            if (typeList.IsNullOrEmpty())
-            {
-                description = "do not depend on no types (always true)";
-            }
-            else
-            {
-                var firstType = typeList.First();
-                description = typeList
-                    .Where(obj => obj != firstType)
-                    .Distinct()
-                    .Aggregate(
-                        "do not depend on \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
+            var description = objectProvider.FormatDescription(
+                "do not depend on any of no types (always true)",
+                "do not depend on",
+                "do not depend on any"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> DoNotHaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            var attributes = new List<Attribute> { firstAttribute };
-            attributes.AddRange(moreAttributes);
-            return DoNotHaveAnyAttributes(attributes);
-        }
-
-        public static IPredicate<T> DoNotHaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            var attributes = new List<Type> { firstAttribute };
-            attributes.AddRange(moreAttributes);
-            return DoNotHaveAnyAttributes(attributes);
-        }
-
         public static IPredicate<T> DoNotHaveAnyAttributes(
             IObjectProvider<Attribute> objectProvider
         )
@@ -1348,146 +769,14 @@ IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
                 return objects.Where(obj => !obj.Attributes.Intersect(types).Any());
             }
 
-            var description = "do not have any " + objectProvider.Description;
-            return new ArchitecturePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            var attributeList = attributes.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects)
-            {
-                return objects.Where(obj => !obj.Attributes.Intersect(attributeList).Any());
-            }
-
-            string description;
-            if (attributeList.IsNullOrEmpty())
-            {
-                description = "do not have one of no attributes (always true)";
-            }
-            else
-            {
-                var firstAttribute = attributeList.First();
-                description = attributeList
-                    .Where(obj => !obj.Equals(firstAttribute))
-                    .Distinct()
-                    .Aggregate(
-                        "do not have attribute \"" + firstAttribute.FullName + "\"",
-                        (current, attribute) => current + " or \"" + attribute.FullName + "\""
-                    );
-            }
-
-            return new EnumerablePredicate<T>(Filter, description);
-        }
-
-        public static IPredicate<T> DoNotHaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            var attributeList = attributes.ToList();
-
-            IEnumerable<T> Filter(IEnumerable<T> objects, Architecture architecture)
-            {
-                var archUnitAttributeList = new List<Attribute>();
-                foreach (var type in attributeList)
-                {
-                    try
-                    {
-                        var archUnitAttribute = architecture.GetAttributeOfType(type);
-                        archUnitAttributeList.Add(archUnitAttribute);
-                    }
-                    catch (TypeDoesNotExistInArchitecture)
-                    {
-                        //ignore, can't have a dependency anyways
-                    }
-                }
-
-                return objects.Where(obj => !obj.Attributes.Intersect(archUnitAttributeList).Any());
-            }
-
-            string description;
-            if (attributeList.IsNullOrEmpty())
-            {
-                description = "do not have one of no attributes (always true)";
-            }
-            else
-            {
-                var firstType = attributeList.First();
-                description = attributeList
-                    .Where(obj => obj != firstType)
-                    .Distinct()
-                    .Aggregate(
-                        "do not have attribute \"" + firstType.FullName + "\"",
-                        (current, obj) => current + " or \"" + obj.FullName + "\""
-                    );
-            }
-
+            var description = objectProvider.FormatDescription(
+                "do not have any of no attributes (always true)",
+                "do not have",
+                "do not have any"
+            );
             return new ArchitecturePredicate<T>(Filter, description);
         }
 
-        public static IPredicate<T> DoNotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return DoNotHaveAnyAttributesWithArguments(argumentValues);
-        }
-
-        public static IPredicate<T> DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return DoNotHaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static IPredicate<T> DoNotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            var argumentValues = new List<object> { firstArgumentValue };
-            argumentValues.AddRange(moreArgumentValues);
-            return DoNotHaveAttributeWithArguments(attribute, argumentValues);
-        }
-
-        public static IPredicate<T> DoNotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return DoNotHaveAnyAttributesWithNamedArguments(attributeArguments);
-        }
-
-        public static IPredicate<T> DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return DoNotHaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
-        public static IPredicate<T> DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            var attributeArguments = new List<(string, object)> { firstAttributeArgument };
-            attributeArguments.AddRange(moreAttributeArguments);
-            return DoNotHaveAttributeWithNamedArguments(attribute, attributeArguments);
-        }
-
         public static IPredicate<T> DoNotHaveAnyAttributesWithArguments(
             IEnumerable<object> argumentValues
         )
@@ -1941,6 +1230,30 @@ public static IPredicate<T> DoNotHaveNameMatching(string pattern)
             );
         }
 
+        public static IPredicate<T> DoNotHaveNameStartingWith(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.NameStartsWith(pattern),
+                "do not have name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> DoNotHaveNameEndingWith(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.NameEndsWith(pattern),
+                "do not have name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> DoNotHaveNameContaining(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.NameContains(pattern),
+                "do not have name containing \"" + pattern + "\""
+            );
+        }
+
         public static IPredicate<T> DoNotHaveFullName(string fullName)
         {
             return new SimplePredicate<T>(
@@ -1957,35 +1270,67 @@ public static IPredicate<T> DoNotHaveFullNameMatching(string pattern)
             );
         }
 
-        public static IPredicate<T> DoNotHaveNameStartingWith(string pattern)
+        public static IPredicate<T> DoNotHaveFullNameStartingWith(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => !obj.NameStartsWith(pattern),
-                "do not have name starting with \"" + pattern + "\""
+                obj => !obj.FullNameStartsWith(pattern),
+                "do not have full name starting with \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> DoNotHaveNameEndingWith(string pattern)
+        public static IPredicate<T> DoNotHaveFullNameEndingWith(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => !obj.NameEndsWith(pattern),
-                "do not have name ending with \"" + pattern + "\""
+                obj => !obj.FullNameEndsWith(pattern),
+                "do not have full name ending with \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> DoNotHaveNameContaining(string pattern)
+        public static IPredicate<T> DoNotHaveFullNameContaining(string pattern)
         {
             return new SimplePredicate<T>(
-                obj => !obj.NameContains(pattern),
-                "do not have name containing \"" + pattern + "\""
+                obj => !obj.FullNameContains(pattern),
+                "do not have full name containing \"" + pattern + "\""
             );
         }
 
-        public static IPredicate<T> DoNotHaveFullNameContaining(string pattern)
+        public static IPredicate<T> DoNotHaveAssemblyQualifiedName(string assemblyQualifiedName)
         {
             return new SimplePredicate<T>(
-                obj => !obj.FullNameContains(pattern),
-                "do not have full name containing \"" + pattern + "\""
+                obj => !obj.AssemblyQualifiedNameEquals(assemblyQualifiedName),
+                "do not have assembly qualified name \"" + assemblyQualifiedName + "\""
+            );
+        }
+
+        public static IPredicate<T> DoNotHaveAssemblyQualifiedNameMatching(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.AssemblyQualifiedNameMatches(pattern),
+                "do not have assembly qualified name matching \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> DoNotHaveAssemblyQualifiedNameStartingWith(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.AssemblyQualifiedNameStartsWith(pattern),
+                "do not have assembly qualified name starting with \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> DoNotHaveAssemblyQualifiedNameEndingWith(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.AssemblyQualifiedNameEndsWith(pattern),
+                "do not have assembly qualified name ending with \"" + pattern + "\""
+            );
+        }
+
+        public static IPredicate<T> DoNotHaveAssemblyQualifiedNameContaining(string pattern)
+        {
+            return new SimplePredicate<T>(
+                obj => !obj.AssemblyQualifiedNameContains(pattern),
+                "do not have assembly qualified name containing \"" + pattern + "\""
             );
         }
 
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs b/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs
index 036ed1d89..037912167 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using ArchUnitNET.Domain;
-using ArchUnitNET.Domain.Extensions;
 using ArchUnitNET.Fluent.Conditions;
 using ArchUnitNET.Fluent.Syntax.Elements.Types;
 using ArchUnitNET.Fluent.Syntax.Elements.Types.Attributes;
@@ -28,644 +27,97 @@ public TRuleTypeShouldConjunction Exist()
             return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
         }
 
-        public TRuleTypeShouldConjunction Be(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            var objectList = new List<ICanBeAnalyzed> { firstObject };
-            objectList.AddRange(moreObjects);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.Be(
-                    new ObjectProvider<ICanBeAnalyzed>(objectList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction Be(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.Be(
-                    new ObjectProvider<ICanBeAnalyzed>(objects.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction Be(IObjectProvider<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.Be(objects));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction CallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            var methodList = new List<MethodMember> { method };
-            methodList.AddRange(moreMethods);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.CallAny(
-                    new ObjectProvider<MethodMember>(methodList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction CallAny(IEnumerable<MethodMember> methods)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.CallAny(
-                    new ObjectProvider<MethodMember>(methods.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction CallAny(IObjectProvider<MethodMember> methods)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.CallAny(methods));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            var typeList = new List<IType> { firstType };
-            typeList.AddRange(moreTypes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.DependOnAny(
-                    new ObjectProvider<IType>(typeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            var typeList = new List<Type> { firstType };
-            typeList.AddRange(moreTypes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.DependOnAny(
-                    new SystemTypeObjectProvider<IType>(typeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IObjectProvider<IType> types)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.DependOnAny(types));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<IType> types)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.DependOnAny(
-                    new ObjectProvider<IType>(types.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<Type> types)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.DependOnAny(
-                    new SystemTypeObjectProvider<IType>(types.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction FollowCustomCondition(ICondition<TRuleType> condition)
-        {
-            _ruleCreator.AddCondition(condition);
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction FollowCustomCondition(
-            Func<TRuleType, ConditionResult> condition,
-            string description
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.FollowCustomCondition(condition, description)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction FollowCustomCondition(
-            Func<TRuleType, bool> condition,
-            string description,
-            string failDescription
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.FollowCustomCondition(
-                    condition,
-                    description,
-                    failDescription
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IType firstType, params IType[] moreTypes)
-        {
-            var typeList = new List<IType> { firstType };
-            typeList.AddRange(moreTypes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyDependOn(
-                    new ObjectProvider<IType>(typeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(Type firstType, params Type[] moreTypes)
-        {
-            var typeList = new List<Type> { firstType };
-            typeList.AddRange(moreTypes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyDependOn(
-                    new SystemTypeObjectProvider<IType>(typeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IObjectProvider<IType> types)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.OnlyDependOn(types));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<IType> types)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyDependOn(
-                    new ObjectProvider<IType>(types.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<Type> types)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyDependOn(
-                    new SystemTypeObjectProvider<IType>(types.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            var attributeList = new List<Attribute> { firstAttribute };
-            attributeList.AddRange(moreAttributes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributes(
-                    new ObjectProvider<Attribute>(attributeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            var attributeList = new List<Type> { firstAttribute };
-            attributeList.AddRange(moreAttributes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributes(
-                    new SystemTypeObjectProvider<Attribute>(attributeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(IObjectProvider<Attribute> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributes(
-                    new ObjectProvider<Attribute>(attributes.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributes(
-                    new SystemTypeObjectProvider<Attribute>(attributes.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            var attributeList = new List<Attribute> { firstAttribute };
-            attributeList.AddRange(moreAttributes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributes(
-                    new ObjectProvider<Attribute>(attributeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            var attributeList = new List<Type> { firstAttribute };
-            attributeList.AddRange(moreAttributes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributes(
-                    new SystemTypeObjectProvider<Attribute>(attributeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(IObjectProvider<Attribute> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributes(
-                    new ObjectProvider<Attribute>(attributes.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributes(
-                    new SystemTypeObjectProvider<Attribute>(attributes.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithArguments(argumentValues)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithArguments(
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithNamedArguments(
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithNamedArguments(
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveName(string name)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.HaveName(name));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameMatching(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveFullName(string fullName)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.HaveFullName(fullName));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveFullNameMatching(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveFullNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameStartingWith(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveNameStartingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameEndingWith(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveNameEndingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameContaining(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveFullNameContaining(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.HaveFullNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction BePrivate()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.BePrivate());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction BePublic()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.BePublic());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction BeProtected()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.BeProtected());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction BeInternal()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.BeInternal());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction BeProtectedInternal()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.BeProtectedInternal());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction BePrivateProtected()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.BePrivateProtected());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        //Relation Conditions
-
-        public ShouldRelateToTypesThat<
-            TRuleTypeShouldConjunction,
-            IType,
-            TRuleType
-        > DependOnAnyTypesThat()
-        {
-            _ruleCreator.BeginComplexCondition(
-                ArchRuleDefinition.Types(true),
-                ObjectConditionsDefinition<TRuleType>.DependOnAnyTypesThat()
-            );
-            return new ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType>(
-                _ruleCreator
-            );
-        }
-
-        public ShouldRelateToTypesThat<
-            TRuleTypeShouldConjunction,
-            IType,
-            TRuleType
-        > OnlyDependOnTypesThat()
-        {
-            _ruleCreator.BeginComplexCondition(
-                ArchRuleDefinition.Types(true),
-                ObjectConditionsDefinition<TRuleType>.OnlyDependOnTypesThat()
-            );
-            return new ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType>(
-                _ruleCreator
-            );
-        }
-
-        public ShouldRelateToAttributesThat<
-            TRuleTypeShouldConjunction,
-            TRuleType
-        > HaveAnyAttributesThat()
-        {
-            _ruleCreator.BeginComplexCondition(
-                Attributes(true),
-                ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesThat()
-            );
-            return new ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType>(
-                _ruleCreator
-            );
-        }
-
-        public ShouldRelateToAttributesThat<
-            TRuleTypeShouldConjunction,
-            TRuleType
-        > OnlyHaveAttributesThat()
-        {
-            _ruleCreator.BeginComplexCondition(
-                Attributes(true),
-                ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributesThat()
-            );
-            return new ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType>(
-                _ruleCreator
-            );
-        }
-
-        //Negations
+        // csharpier-ignore-start
+        public TRuleTypeShouldConjunction Be(params ICanBeAnalyzed[] objects) => Be(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction Be(IEnumerable<ICanBeAnalyzed> objects) => Be(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction Be(IObjectProvider<ICanBeAnalyzed> objects) => AddCondition(ObjectConditionsDefinition<TRuleType>.Be(objects));
+
+        public TRuleTypeShouldConjunction CallAny(params MethodMember[] methods) => CallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction CallAny(IEnumerable<MethodMember> methods) => CallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction CallAny(IObjectProvider<MethodMember> methods) => AddCondition(ObjectConditionsDefinition<TRuleType>.CallAny(methods));
+
+        public TRuleTypeShouldConjunction DependOnAny() => DependOnAny(new ObjectProvider<IType>());
+        public TRuleTypeShouldConjunction DependOnAny(params IType[] types) => DependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DependOnAny(params Type[] types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DependOnAny(IObjectProvider<IType> types) => AddCondition(ObjectConditionsDefinition<TRuleType>.DependOnAny(types));
+        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<IType> types) => DependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<Type> types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
+
+        public TRuleTypeShouldConjunction FollowCustomCondition(ICondition<TRuleType> condition) => AddCondition(condition);
+        public TRuleTypeShouldConjunction FollowCustomCondition(Func<TRuleType, ConditionResult> condition, string description) => AddCondition(ObjectConditionsDefinition<TRuleType>.FollowCustomCondition(condition, description));
+        public TRuleTypeShouldConjunction FollowCustomCondition(Func<TRuleType, bool> condition, string description, string failDescription) => AddCondition(ObjectConditionsDefinition<TRuleType>.FollowCustomCondition(condition, description, failDescription));
+
+        public TRuleTypeShouldConjunction OnlyDependOn() => OnlyDependOn(new ObjectProvider<IType>());
+        public TRuleTypeShouldConjunction OnlyDependOn(params IType[] types) => OnlyDependOn(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(params Type[] types) => OnlyDependOn(new SystemTypeObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(IObjectProvider<IType> types) => AddCondition(ObjectConditionsDefinition<TRuleType>.OnlyDependOn(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<IType> types) => OnlyDependOn(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<Type> types) => OnlyDependOn(new SystemTypeObjectProvider<IType>(types));
+
+        public TRuleTypeShouldConjunction HaveAnyAttributes() => HaveAnyAttributes(new ObjectProvider<Attribute>());
+        public TRuleTypeShouldConjunction HaveAnyAttributes(params Attribute[] attributes) => HaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(params Type[] attributes) => HaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(IObjectProvider<Attribute> attributes) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAnyAttributes(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Attribute> attributes) => HaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Type> attributes) => HaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TRuleTypeShouldConjunction OnlyHaveAttributes() => OnlyHaveAttributes(new ObjectProvider<Attribute>());
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(params Attribute[] attributes) => OnlyHaveAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(params Type[] attributes) => OnlyHaveAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(IObjectProvider<Attribute> attributes) => AddCondition(ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributes(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Attribute> attributes) => OnlyHaveAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Type> attributes) => OnlyHaveAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithArguments(argumentValues));
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithArguments(new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesWithNamedArguments(attributeArguments));
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAnyAttributesWithNamedArguments(new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TRuleTypeShouldConjunction HaveName(string name) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveName(name));
+        public TRuleTypeShouldConjunction HaveNameMatching(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveNameMatching(pattern));
+        public TRuleTypeShouldConjunction HaveNameStartingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction HaveNameEndingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction HaveNameContaining(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction HaveFullName(string fullName) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveFullName(fullName));
+        public TRuleTypeShouldConjunction HaveFullNameMatching(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveFullNameMatching(pattern));
+        public TRuleTypeShouldConjunction HaveFullNameStartingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveFullNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction HaveFullNameEndingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveFullNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction HaveFullNameContaining(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveFullNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedName(string assemblyQualifiedName) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAssemblyQualifiedName(assemblyQualifiedName));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameMatching(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAssemblyQualifiedNameMatching(pattern));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameStartingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAssemblyQualifiedNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameEndingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAssemblyQualifiedNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameContaining(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.HaveAssemblyQualifiedNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction BePrivate() => AddCondition(ObjectConditionsDefinition<TRuleType>.BePrivate());
+        public TRuleTypeShouldConjunction BePublic() => AddCondition(ObjectConditionsDefinition<TRuleType>.BePublic());
+        public TRuleTypeShouldConjunction BeProtected() => AddCondition(ObjectConditionsDefinition<TRuleType>.BeProtected());
+        public TRuleTypeShouldConjunction BeInternal() => AddCondition(ObjectConditionsDefinition<TRuleType>.BeInternal());
+        public TRuleTypeShouldConjunction BeProtectedInternal() => AddCondition(ObjectConditionsDefinition<TRuleType>.BeProtectedInternal());
+        public TRuleTypeShouldConjunction BePrivateProtected() => AddCondition(ObjectConditionsDefinition<TRuleType>.BePrivateProtected());
+
+        // Relation Conditions
+
+        public ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType> DependOnAnyTypesThat() => BeginComplexTypeCondition(ObjectConditionsDefinition<TRuleType>.DependOnAnyTypesThat());
+        public ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType> OnlyDependOnTypesThat() => BeginComplexTypeCondition(ObjectConditionsDefinition<TRuleType>.OnlyDependOnTypesThat());
+
+        public ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> HaveAnyAttributesThat() => BeginComplexAttributeCondition(ObjectConditionsDefinition<TRuleType>.HaveAnyAttributesThat());
+        public ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> OnlyHaveAttributesThat() => BeginComplexAttributeCondition(ObjectConditionsDefinition<TRuleType>.OnlyHaveAttributesThat());
+
+        // Negations
 
         public TRuleTypeShouldConjunction NotExist()
         {
@@ -674,479 +126,99 @@ public TRuleTypeShouldConjunction NotExist()
             return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
         }
 
-        public TRuleTypeShouldConjunction NotBe(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            var objectList = new List<ICanBeAnalyzed> { firstObject };
-            objectList.AddRange(moreObjects);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotBe(
-                    new ObjectProvider<ICanBeAnalyzed>(objectList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotBe(params ICanBeAnalyzed[] objects) => NotBe(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction NotBe(IEnumerable<ICanBeAnalyzed> objects) => NotBe(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction NotBe(IObjectProvider<ICanBeAnalyzed> objects) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBe(objects));
 
-        public TRuleTypeShouldConjunction NotBe(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotBe(
-                    new ObjectProvider<ICanBeAnalyzed>(objects.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotCallAny(params MethodMember[] methods) => NotCallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction NotCallAny(IEnumerable<MethodMember> methods) => NotCallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction NotCallAny(IObjectProvider<MethodMember> methods) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotCallAny(methods));
 
-        public TRuleTypeShouldConjunction NotBe(IObjectProvider<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotBe(objects));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotDependOnAny() => NotDependOnAny(new ObjectProvider<IType>());
+        public TRuleTypeShouldConjunction NotDependOnAny(params IType[] types) => NotDependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction NotDependOnAny(params Type[] types) => NotDependOnAny(new SystemTypeObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction NotDependOnAny(IObjectProvider<IType> types) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotDependOnAny(types));
+        public TRuleTypeShouldConjunction NotDependOnAny(IEnumerable<IType> types) => NotDependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction NotDependOnAny(IEnumerable<Type> types) => NotDependOnAny(new SystemTypeObjectProvider<IType>(types));
 
-        public TRuleTypeShouldConjunction NotCallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            var methods = new List<MethodMember> { method };
-            methods.AddRange(moreMethods);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotCallAny(
-                    new ObjectProvider<MethodMember>(methods)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveAnyAttributes() => NotHaveAnyAttributes(new ObjectProvider<Attribute>());
+        public TRuleTypeShouldConjunction NotHaveAnyAttributes(params Attribute[] attributes) => NotHaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction NotHaveAnyAttributes(params Type[] attributes) => NotHaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction NotHaveAnyAttributes(IObjectProvider<Attribute> attributes) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributes(attributes));
+        public TRuleTypeShouldConjunction NotHaveAnyAttributes(IEnumerable<Attribute> attributes) => NotHaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction NotHaveAnyAttributes(IEnumerable<Type> attributes) => NotHaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
 
-        public TRuleTypeShouldConjunction NotCallAny(IEnumerable<MethodMember> methods)
-        {
-            var methodList = methods.ToList();
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotCallAny(
-                    new ObjectProvider<MethodMember>(methodList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithArguments(argumentValues));
+        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithArguments(new[] { firstArgumentValue }.Concat(moreArgumentValues)));
 
-        public TRuleTypeShouldConjunction NotCallAny(IObjectProvider<MethodMember> methods)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotCallAny(methods));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
 
-        public TRuleTypeShouldConjunction NotDependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            var typeList = new List<IType> { firstType };
-            typeList.AddRange(moreTypes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotDependOnAny(
-                    new ObjectProvider<IType>(typeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithNamedArguments(attributeArguments));
+        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => NotHaveAnyAttributesWithNamedArguments(new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
 
-        public TRuleTypeShouldConjunction NotDependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            var typeList = new List<Type> { firstType };
-            typeList.AddRange(moreTypes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotDependOnAny(
-                    new SystemTypeObjectProvider<IType>(typeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => NotHaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => NotHaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
 
-        public TRuleTypeShouldConjunction NotDependOnAny(IObjectProvider<IType> types)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotDependOnAny(types));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveName(string name) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveName(name));
+        public TRuleTypeShouldConjunction NotHaveNameMatching(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveNameMatching(pattern));
+        public TRuleTypeShouldConjunction NotHaveNameStartingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction NotHaveNameEndingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction NotHaveNameContaining(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveNameContaining(pattern));
 
-        public TRuleTypeShouldConjunction NotDependOnAny(IEnumerable<IType> types)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotDependOnAny(
-                    new ObjectProvider<IType>(types.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotDependOnAny(IEnumerable<Type> types)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotDependOnAny(
-                    new SystemTypeObjectProvider<IType>(types.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveFullName(string fullName) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveFullName(fullName));
+        public TRuleTypeShouldConjunction NotHaveFullNameMatching(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveFullNameMatching(pattern));
+        public TRuleTypeShouldConjunction NotHaveFullNameStartingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveFullNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction NotHaveFullNameEndingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveFullNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction NotHaveFullNameContaining(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveFullNameContaining(pattern));
 
-        public TRuleTypeShouldConjunction NotHaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            var attributeList = new List<Attribute> { firstAttribute };
-            attributeList.AddRange(moreAttributes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributes(
-                    new ObjectProvider<Attribute>(attributeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            var attributeList = new List<Type> { firstAttribute };
-            attributeList.AddRange(moreAttributes);
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributes(
-                    new SystemTypeObjectProvider<Attribute>(attributeList)
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotHaveAssemblyQualifiedName(string assemblyQualifiedName) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAssemblyQualifiedName(assemblyQualifiedName));
+        public TRuleTypeShouldConjunction NotHaveAssemblyQualifiedNameMatching(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAssemblyQualifiedNameMatching(pattern));
+        public TRuleTypeShouldConjunction NotHaveAssemblyQualifiedNameStartingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAssemblyQualifiedNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction NotHaveAssemblyQualifiedNameEndingWith(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAssemblyQualifiedNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction NotHaveAssemblyQualifiedNameContaining(string pattern) => AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAssemblyQualifiedNameContaining(pattern));
 
-        public TRuleTypeShouldConjunction NotHaveAnyAttributes(
-            IObjectProvider<Attribute> attributes
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public TRuleTypeShouldConjunction NotBePrivate() => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBePrivate());
+        public TRuleTypeShouldConjunction NotBePublic() => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBePublic());
+        public TRuleTypeShouldConjunction NotBeProtected() => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBeProtected());
+        public TRuleTypeShouldConjunction NotBeInternal() => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBeInternal());
+        public TRuleTypeShouldConjunction NotBeProtectedInternal() => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBeProtectedInternal());
+        public TRuleTypeShouldConjunction NotBePrivateProtected() => AddCondition(ObjectConditionsDefinition<TRuleType>.NotBePrivateProtected());
 
-        public TRuleTypeShouldConjunction NotHaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributes(
-                    new ObjectProvider<Attribute>(attributes.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        // Relation Condition Negations
 
-        public TRuleTypeShouldConjunction NotHaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributes(
-                    new SystemTypeObjectProvider<Attribute>(attributes.ToList())
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
+        public ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType> NotDependOnAnyTypesThat() => BeginComplexTypeCondition(ObjectConditionsDefinition<TRuleType>.NotDependOnAnyTypesThat());
+        public ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> NotHaveAnyAttributesThat() => BeginComplexAttributeCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesThat());
+        // csharpier-ignore-end
 
-        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithArguments(
-            IEnumerable<object> argumentValues
-        )
+        private TRuleTypeShouldConjunction AddCondition(ICondition<TRuleType> condition)
         {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithArguments(
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithArguments(
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithNamedArguments(
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesWithNamedArguments(
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveName(string name)
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotHaveName(name));
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveNameMatching(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveFullName(string fullName)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveFullName(fullName)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveFullNameMatching(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveFullNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveNameStartingWith(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveNameStartingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveNameEndingWith(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveNameEndingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveNameContaining(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotHaveFullNameContaining(string pattern)
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotHaveFullNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotBePrivate()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotBePrivate());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotBePublic()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotBePublic());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotBeProtected()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotBeProtected());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotBeInternal()
-        {
-            _ruleCreator.AddCondition(ObjectConditionsDefinition<TRuleType>.NotBeInternal());
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotBeProtectedInternal()
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotBeProtectedInternal()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction NotBePrivateProtected()
-        {
-            _ruleCreator.AddCondition(
-                ObjectConditionsDefinition<TRuleType>.NotBePrivateProtected()
-            );
+            _ruleCreator.AddCondition(condition);
             return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
         }
 
-        //Relation Condition Negations
-
-        public ShouldRelateToTypesThat<
+        private ShouldRelateToTypesThat<
             TRuleTypeShouldConjunction,
             IType,
             TRuleType
-        > NotDependOnAnyTypesThat()
+        > BeginComplexTypeCondition(RelationCondition<TRuleType, IType> relationCondition)
         {
-            _ruleCreator.BeginComplexCondition(
-                ArchRuleDefinition.Types(true),
-                ObjectConditionsDefinition<TRuleType>.NotDependOnAnyTypesThat()
-            );
+            _ruleCreator.BeginComplexCondition(ArchRuleDefinition.Types(true), relationCondition);
             return new ShouldRelateToTypesThat<TRuleTypeShouldConjunction, IType, TRuleType>(
                 _ruleCreator
             );
         }
 
-        public ShouldRelateToAttributesThat<
+        private ShouldRelateToAttributesThat<
             TRuleTypeShouldConjunction,
             TRuleType
-        > NotHaveAnyAttributesThat()
+        > BeginComplexAttributeCondition(RelationCondition<TRuleType, Attribute> relationCondition)
         {
-            _ruleCreator.BeginComplexCondition(
-                Attributes(true),
-                ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesThat()
-            );
+            _ruleCreator.BeginComplexCondition(Attributes(true), relationCondition);
             return new ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType>(
                 _ruleCreator
             );
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/ShouldRelateToObjectsThat.cs b/ArchUnitNET/Fluent/Syntax/Elements/ShouldRelateToObjectsThat.cs
index 529115105..3eac066b5 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/ShouldRelateToObjectsThat.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/ShouldRelateToObjectsThat.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using ArchUnitNET.Domain;
 using ArchUnitNET.Fluent.Predicates;
 using static ArchUnitNET.Fluent.Syntax.ConjunctionFactory;
@@ -16,985 +17,159 @@ public class ShouldRelateToObjectsThat<TRuleTypeShouldConjunction, TReferenceTyp
         protected ShouldRelateToObjectsThat(IArchRuleCreator<TRuleType> ruleCreator)
             : base(ruleCreator) { }
 
-        public TRuleTypeShouldConjunction Are(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.Are(firstObject, moreObjects)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction Are(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.Are(objects)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction Are(IObjectProvider<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.Are(objects)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction CallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.CallAny(method, moreMethods)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction CallAny(IEnumerable<MethodMember> methods)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.CallAny(methods)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction CallAny(IObjectProvider<MethodMember> methods)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.CallAny(methods)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DependOnAny(firstType, moreTypes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IType firstType, params IType[] moreTypes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DependOnAny(firstType, moreTypes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IObjectProvider<IType> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DependOnAny(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<IType> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DependOnAny(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<Type> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DependOnAny(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction FollowCustomPredicate(
+        // csharpier-ignore-start
+        public TRuleTypeShouldConjunction Are(params ICanBeAnalyzed[] objects) => Are(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction Are(IEnumerable<ICanBeAnalyzed> objects) => Are(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction Are(IObjectProvider<ICanBeAnalyzed> objects) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.Are(objects));
+
+        public TRuleTypeShouldConjunction CallAny(params MethodMember[] methods) => CallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction CallAny(IEnumerable<MethodMember> methods) => CallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction CallAny(IObjectProvider<MethodMember> methods) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.CallAny(methods));
+
+        public TRuleTypeShouldConjunction DependOnAny() => DependOnAny(new ObjectProvider<IType>());
+        public TRuleTypeShouldConjunction DependOnAny(params IType[] types) => DependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DependOnAny(params Type[] types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DependOnAny(IObjectProvider<IType> types) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DependOnAny(types));
+        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<IType> types) => DependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DependOnAny(IEnumerable<Type> types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
+
+        public TRuleTypeShouldConjunction FollowCustomPredicate(IPredicate<TReferenceType> predicate) => ContinueComplexCondition(predicate);
+        public TRuleTypeShouldConjunction FollowCustomPredicate(Func<TReferenceType, bool> predicate, string description) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.FollowCustomPredicate(predicate, description));
+
+        public TRuleTypeShouldConjunction OnlyDependOn() => OnlyDependOn(new ObjectProvider<IType>());
+        public TRuleTypeShouldConjunction OnlyDependOn(params IType[] types) => OnlyDependOn(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(params Type[] types) => OnlyDependOn(new SystemTypeObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(IObjectProvider<IType> types) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.OnlyDependOn(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<IType> types) => OnlyDependOn(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<Type> types) => OnlyDependOn(new SystemTypeObjectProvider<IType>(types));
+
+        public TRuleTypeShouldConjunction HaveAnyAttributes() => HaveAnyAttributes(new ObjectProvider<Attribute>());
+        public TRuleTypeShouldConjunction HaveAnyAttributes(params Attribute[] attributes) => HaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(params Type[] attributes) => HaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(IObjectProvider<Attribute> attributes) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributes(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Attribute> attributes) => HaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Type> attributes) => HaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TRuleTypeShouldConjunction OnlyHaveAttributes() => OnlyHaveAttributes(new ObjectProvider<Attribute>());
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(params Attribute[] attributes) => OnlyHaveAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(params Type[] attributes) => OnlyHaveAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(IObjectProvider<Attribute> attributes) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.OnlyHaveAttributes(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Attribute> attributes) => OnlyHaveAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Type> attributes) => OnlyHaveAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithArguments(argumentValues));
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithArguments(new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction HaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithNamedArguments(attributeArguments));
+        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAnyAttributesWithNamedArguments(new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => HaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TRuleTypeShouldConjunction HaveName(string name) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveName(name));
+        public TRuleTypeShouldConjunction HaveNameMatching(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveNameMatching(pattern));
+        public TRuleTypeShouldConjunction HaveNameStartingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction HaveNameEndingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction HaveNameContaining(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction HaveFullName(string fullName) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveFullName(fullName));
+        public TRuleTypeShouldConjunction HaveFullNameMatching(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveFullNameMatching(pattern));
+        public TRuleTypeShouldConjunction HaveFullNameStartingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveFullNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction HaveFullNameEndingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveFullNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction HaveFullNameContaining(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveFullNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedName(string assemblyQualifiedName) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAssemblyQualifiedName(assemblyQualifiedName));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameMatching(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAssemblyQualifiedNameMatching(pattern));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameStartingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAssemblyQualifiedNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameEndingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAssemblyQualifiedNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction HaveAssemblyQualifiedNameContaining(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.HaveAssemblyQualifiedNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction ArePrivate() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.ArePrivate());
+        public TRuleTypeShouldConjunction ArePublic() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.ArePublic());
+        public TRuleTypeShouldConjunction AreProtected() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreProtected());
+        public TRuleTypeShouldConjunction AreInternal() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreInternal());
+        public TRuleTypeShouldConjunction AreProtectedInternal() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreProtectedInternal());
+        public TRuleTypeShouldConjunction ArePrivateProtected() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.ArePrivateProtected());
+
+        // Negations
+
+        public TRuleTypeShouldConjunction AreNot(params ICanBeAnalyzed[] objects) => AreNot(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction AreNot(IEnumerable<ICanBeAnalyzed> objects) => AreNot(new ObjectProvider<ICanBeAnalyzed>(objects));
+        public TRuleTypeShouldConjunction AreNot(IObjectProvider<ICanBeAnalyzed> objects) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNot(objects));
+
+        public TRuleTypeShouldConjunction DoNotCallAny(params MethodMember[] methods) => DoNotCallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction DoNotCallAny(IEnumerable<MethodMember> methods) => DoNotCallAny(new ObjectProvider<MethodMember>(methods));
+        public TRuleTypeShouldConjunction DoNotCallAny(IObjectProvider<MethodMember> methods) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotCallAny(methods));
+
+        public TRuleTypeShouldConjunction DoNotDependOnAny() => DoNotDependOnAny(new ObjectProvider<IType>());
+        public TRuleTypeShouldConjunction DoNotDependOnAny(params IType[] types) => DoNotDependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DoNotDependOnAny(params Type[] types) => DoNotDependOnAny(new SystemTypeObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DoNotDependOnAny(IObjectProvider<IType> types) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotDependOnAny(types));
+        public TRuleTypeShouldConjunction DoNotDependOnAny(IEnumerable<IType> types) => DoNotDependOnAny(new ObjectProvider<IType>(types));
+        public TRuleTypeShouldConjunction DoNotDependOnAny(IEnumerable<Type> types) => DoNotDependOnAny(new SystemTypeObjectProvider<IType>(types));
+
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes() => DoNotHaveAnyAttributes(new ObjectProvider<Attribute>());
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(params Attribute[] attributes) => DoNotHaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(params Type[] attributes) => DoNotHaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(IObjectProvider<Attribute> attributes) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributes(attributes));
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes) => DoNotHaveAnyAttributes(new ObjectProvider<Attribute>(attributes));
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(IEnumerable<Type> attributes) => DoNotHaveAnyAttributes(new SystemTypeObjectProvider<Attribute>(attributes));
+
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithArguments(argumentValues));
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithArguments(object firstArgumentValue, params object[] moreArgumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithArguments(new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(Attribute attribute, object firstArgumentValue, params object[] moreArgumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(attribute, argumentValues));
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(Type attribute, object firstArgumentValue, params object[] moreArgumentValues) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(attribute, new[] { firstArgumentValue }.Concat(moreArgumentValues)));
+
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithNamedArguments(attributeArguments));
+        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithNamedArguments((string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => DoNotHaveAnyAttributesWithNamedArguments(new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(Attribute attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => DoNotHaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithNamedArguments(attribute, attributeArguments));
+        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(Type attribute, (string, object) firstAttributeArgument, params (string, object)[] moreAttributeArguments) => DoNotHaveAttributeWithNamedArguments(attribute, new[] { firstAttributeArgument }.Concat(moreAttributeArguments));
+
+        public TRuleTypeShouldConjunction DoNotHaveName(string name) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveName(name));
+        public TRuleTypeShouldConjunction DoNotHaveNameMatching(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameMatching(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveNameStartingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveNameEndingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveNameContaining(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction DoNotHaveFullName(string fullName) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullName(fullName));
+        public TRuleTypeShouldConjunction DoNotHaveFullNameMatching(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullNameMatching(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveFullNameStartingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveFullNameEndingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveFullNameContaining(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction DoNotHaveAssemblyQualifiedName(string assemblyQualifiedName) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAssemblyQualifiedName(assemblyQualifiedName));
+        public TRuleTypeShouldConjunction DoNotHaveAssemblyQualifiedNameMatching(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAssemblyQualifiedNameMatching(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveAssemblyQualifiedNameStartingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAssemblyQualifiedNameStartingWith(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveAssemblyQualifiedNameEndingWith(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAssemblyQualifiedNameEndingWith(pattern));
+        public TRuleTypeShouldConjunction DoNotHaveAssemblyQualifiedNameContaining(string pattern) => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAssemblyQualifiedNameContaining(pattern));
+
+        public TRuleTypeShouldConjunction AreNotPrivate() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNotPrivate());
+        public TRuleTypeShouldConjunction AreNotPublic() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNotPublic());
+        public TRuleTypeShouldConjunction AreNotProtected() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNotProtected());
+        public TRuleTypeShouldConjunction AreNotInternal() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNotInternal());
+        public TRuleTypeShouldConjunction AreNotProtectedInternal() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNotProtectedInternal());
+        public TRuleTypeShouldConjunction AreNotPrivateProtected() => ContinueComplexCondition(ObjectPredicatesDefinition<TReferenceType>.AreNotPrivateProtected());
+        // csharpier-ignore-end
+
+        private TRuleTypeShouldConjunction ContinueComplexCondition(
             IPredicate<TReferenceType> predicate
         )
         {
             _ruleCreator.ContinueComplexCondition(predicate);
             return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
         }
-
-        public TRuleTypeShouldConjunction FollowCustomPredicate(
-            Func<TReferenceType, bool> predicate,
-            string description
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.FollowCustomPredicate(
-                    predicate,
-                    description
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(Type firstType, params Type[] moreTypes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyDependOn(firstType, moreTypes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IType firstType, params IType[] moreTypes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyDependOn(firstType, moreTypes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IObjectProvider<IType> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyDependOn(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<IType> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyDependOn(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyDependOn(IEnumerable<Type> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyDependOn(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(IObjectProvider<Attribute> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyHaveAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyHaveAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(IObjectProvider<Attribute> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction OnlyHaveAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.OnlyHaveAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithArguments(
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithArguments(
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithNamedArguments(
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAnyAttributesWithNamedArguments(
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveName(string name)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveName(name)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameMatching(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveFullName(string fullName)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveFullName(fullName)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveFullNameMatching(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveFullNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameStartingWith(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveNameStartingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameEndingWith(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveNameEndingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveNameContaining(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction HaveFullNameContaining(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.HaveFullNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction ArePrivate()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.ArePrivate()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction ArePublic()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.ArePublic()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreProtected()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreProtected()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreInternal()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreInternal()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreProtectedInternal()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreProtectedInternal()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction ArePrivateProtected()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.ArePrivateProtected()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        //Negations
-
-        public TRuleTypeShouldConjunction AreNot(
-            ICanBeAnalyzed firstObject,
-            params ICanBeAnalyzed[] moreObjects
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNot(firstObject, moreObjects)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNot(IEnumerable<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNot(objects)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNot(IObjectProvider<ICanBeAnalyzed> objects)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNot(objects)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotCallAny(
-            MethodMember method,
-            params MethodMember[] moreMethods
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotCallAny(method, moreMethods)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotCallAny(IEnumerable<MethodMember> methods)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotCallAny(methods)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotCallAny(IObjectProvider<MethodMember> methods)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotCallAny(methods)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotDependOnAny(Type firstType, params Type[] moreTypes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotDependOnAny(firstType, moreTypes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotDependOnAny(
-            IType firstType,
-            params IType[] moreTypes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotDependOnAny(firstType, moreTypes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotDependOnAny(IObjectProvider<IType> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotDependOnAny(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotDependOnAny(IEnumerable<IType> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotDependOnAny(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotDependOnAny(IEnumerable<Type> types)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotDependOnAny(types)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(
-            Type firstAttribute,
-            params Type[] moreAttributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(
-            Attribute firstAttribute,
-            params Attribute[] moreAttributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributes(
-                    firstAttribute,
-                    moreAttributes
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(
-            IObjectProvider<Attribute> attributes
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributes(IEnumerable<Type> attributes)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributes(attributes)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithArguments(
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithArguments(
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithArguments(
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithArguments(
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(
-            Attribute attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(
-            Type attribute,
-            IEnumerable<object> argumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    argumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithArguments(
-            Type attribute,
-            object firstArgumentValue,
-            params object[] moreArgumentValues
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithArguments(
-                    attribute,
-                    firstArgumentValue,
-                    moreArgumentValues
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithNamedArguments(
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithNamedArguments(
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAnyAttributesWithNamedArguments(
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAnyAttributesWithNamedArguments(
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(
-            Attribute attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            IEnumerable<(string, object)> attributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    attributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveAttributeWithNamedArguments(
-            Type attribute,
-            (string, object) firstAttributeArgument,
-            params (string, object)[] moreAttributeArguments
-        )
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveAttributeWithNamedArguments(
-                    attribute,
-                    firstAttributeArgument,
-                    moreAttributeArguments
-                )
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveName(string name)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveName(name)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveNameMatching(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveFullName(string fullName)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullName(fullName)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveFullNameMatching(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullNameMatching(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveNameStartingWith(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameStartingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveNameEndingWith(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameEndingWith(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveNameContaining(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction DoNotHaveFullNameContaining(string pattern)
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.DoNotHaveFullNameContaining(pattern)
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNotPrivate()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNotPrivate()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNotPublic()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNotPublic()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNotProtected()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNotProtected()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNotInternal()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNotInternal()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNotProtectedInternal()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNotProtectedInternal()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
-
-        public TRuleTypeShouldConjunction AreNotPrivateProtected()
-        {
-            _ruleCreator.ContinueComplexCondition(
-                ObjectPredicatesDefinition<TReferenceType>.AreNotPrivateProtected()
-            );
-            return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
-        }
     }
 }
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs
index 19f9793bd..c4b1eb3d3 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs
@@ -7,7 +7,6 @@
 using ArchUnitNET.Domain.Extensions;
 using ArchUnitNET.Domain.PlantUml.Import;
 using ArchUnitNET.Fluent.Conditions;
-using static ArchUnitNET.Fluent.Syntax.DescriptionHelpers;
 using Enum = ArchUnitNET.Domain.Enum;
 
 namespace ArchUnitNET.Fluent.Syntax.Elements.Types
@@ -564,11 +563,10 @@ Architecture architecture
                 }
             }
 
-            var description = SelectDescription(
+            var description = interfaces.FormatDescription(
                 "implement any interface",
                 "implement",
-                "implement any",
-                interfaces
+                "implement any"
             );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
@@ -1187,11 +1185,10 @@ Architecture architecture
                 }
             }
 
-            var description = SelectDescription(
+            var description = interfaces.FormatDescription(
                 "not implement any interface",
                 "not implement",
-                "not implement any",
-                interfaces
+                "not implement any"
             );
             return new ArchitectureCondition<TRuleType>(Condition, description);
         }
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypePredicatesDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypePredicatesDefinition.cs
index 4e91be64d..3244b7f6d 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypePredicatesDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypePredicatesDefinition.cs
@@ -5,7 +5,6 @@
 using ArchUnitNET.Domain.Exceptions;
 using ArchUnitNET.Domain.Extensions;
 using ArchUnitNET.Fluent.Predicates;
-using static ArchUnitNET.Fluent.Syntax.DescriptionHelpers;
 using Assembly = System.Reflection.Assembly;
 using Enum = ArchUnitNET.Domain.Enum;
 
@@ -353,11 +352,10 @@ IEnumerable<T> Condition(IEnumerable<T> ruleTypes, Architecture architecture)
                         : type.ImplementedInterfaces.Any()
                 );
             }
-            var description = SelectDescription(
+            var description = interfaces.FormatDescription(
                 "implement any interface",
                 "implement",
-                "implement any",
-                interfaces
+                "implement any"
             );
             return new ArchitecturePredicate<T>(Condition, description);
         }
@@ -702,11 +700,10 @@ IEnumerable<T> Condition(IEnumerable<T> ruleTypes, Architecture architecture)
                         : !type.ImplementedInterfaces.Any()
                 );
             }
-            var description = SelectDescription(
+            var description = interfaces.FormatDescription(
                 "do not implement any interface",
                 "do not implement",
-                "do not implement any",
-                interfaces
+                "do not implement any"
             );
             return new ArchitecturePredicate<T>(Condition, description);
         }
diff --git a/ArchUnitNETTests/Fluent/ObjectConditionsErrorMessagesTests.cs b/ArchUnitNETTests/Fluent/ObjectConditionsErrorMessagesTests.cs
deleted file mode 100644
index 0405c3e57..000000000
--- a/ArchUnitNETTests/Fluent/ObjectConditionsErrorMessagesTests.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-using System.Linq;
-using ArchUnitNET.Domain;
-using ArchUnitNET.Fluent;
-using TestAssembly;
-using Xunit;
-using static ArchUnitNET.Fluent.ArchRuleDefinition;
-
-namespace ArchUnitNETTests.Fluent
-{
-    public class ObjectConditionsErrorMessagesTests
-    {
-        private static readonly Architecture Architecture =
-            StaticTestArchitectures.ArchUnitNETTestAssemblyArchitecture;
-
-        private void AssertFailsWithErrorMessage(IArchRule rule, string errorMessage)
-        {
-            var evaluationResults = rule.Evaluate(Architecture);
-            var failedResults = evaluationResults.Where(r => !r.Passed);
-            Assert.Equal(errorMessage, failedResults.Single().Description);
-        }
-
-        [Fact]
-        public void OnlyListForbiddenITypesInError()
-        {
-            var rule = Classes()
-                .That()
-                .Are(typeof(Class1))
-                .Should()
-                .NotDependOnAnyTypesThat()
-                .Are(typeof(Class2));
-            AssertFailsWithErrorMessage(
-                rule,
-                "TestAssembly.Class1 does depend on TestAssembly.Class2"
-            );
-        }
-
-        [Fact]
-        public void OnlyListForbiddenTypesInError()
-        {
-            var rule = Classes().That().Are(typeof(Class1)).Should().NotDependOnAny(typeof(Class2));
-            AssertFailsWithErrorMessage(
-                rule,
-                "TestAssembly.Class1 does depend on TestAssembly.Class2"
-            );
-        }
-
-        [Fact]
-        public void OnlyListForbiddenMethodsInErrors()
-        {
-            var rule = MethodMembers()
-                .That()
-                .AreDeclaredIn(typeof(ClassCallingOtherMethod))
-                .Should()
-                .NotCallAny(MethodMembers().That().AreDeclaredIn(typeof(Class1)));
-            AssertFailsWithErrorMessage(
-                rule,
-                "System.Void TestAssembly.ClassCallingOtherMethod::CallingOther(TestAssembly.Class1)"
-                    + " does call System.String TestAssembly.Class1::AccessClass2(System.Int32)"
-            );
-        }
-
-        [Fact]
-        public void OnlyListForbiddenMethodsFromEnumerableInErrors()
-        {
-            var methodsInClass1 = MethodMembers()
-                .That()
-                .AreDeclaredIn(typeof(Class1))
-                .GetObjects(Architecture);
-            var rule = MethodMembers()
-                .That()
-                .AreDeclaredIn(typeof(ClassCallingOtherMethod))
-                .Should()
-                .NotCallAny(methodsInClass1);
-            AssertFailsWithErrorMessage(
-                rule,
-                "System.Void TestAssembly.ClassCallingOtherMethod::CallingOther(TestAssembly.Class1)"
-                    + " does call System.String TestAssembly.Class1::AccessClass2(System.Int32)"
-            );
-        }
-    }
-}
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs b/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs
index e01ea7d0c..c2861b3bf 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs
@@ -27,8 +27,8 @@ public async Task AreTest()
             Types().That().Are(helper.ChildClass),
             Types().That().Are(helper.ChildClassSystemType),
             Types().That().Are(Classes().That().Are(helper.ChildClass)),
-            Types().That().Are([helper.ChildClass]),
-            Types().That().Are([helper.ChildClassSystemType]),
+            Types().That().Are(new List<ICanBeAnalyzed> { helper.ChildClass }),
+            Types().That().Are(new List<System.Type> { helper.ChildClassSystemType }),
         };
         foreach (var predicate in predicates)
         {
@@ -40,8 +40,8 @@ public async Task AreTest()
             Types().That().Are(helper.BaseClass, helper.ChildClass),
             Types().That().Are(helper.BaseClassSystemType, helper.ChildClassSystemType),
             Types().That().Are(Classes().That().Are(helper.BaseClass, helper.ChildClass)),
-            Types().That().Are([helper.BaseClass, helper.ChildClass]),
-            Types().That().Are([helper.BaseClassSystemType, helper.ChildClassSystemType]),
+            Types().That().Are(new List<ICanBeAnalyzed> { helper.BaseClass, helper.ChildClass }),
+            Types().That().Are(new List<System.Type> { helper.BaseClassSystemType, helper.ChildClassSystemType }),
         };
         foreach (var predicate in predicates)
         {
@@ -49,8 +49,9 @@ public async Task AreTest()
         }
 
         // Empty arguments
+        Assert.Equal([.. Types().That().Are().GetObjects(helper.Architecture)], new List<IType>());
         Assert.Equal([.. Types().That().Are(new List<IType>()).GetObjects(helper.Architecture)], new List<IType>());
-        Assert.Equal([.. Types().That().Are([]).GetObjects(helper.Architecture)], new List<IType>());
+        Assert.Equal([.. Types().That().Are(new List<System.Type>()).GetObjects(helper.Architecture)], new List<IType>());
 
         // Empty inputs
         Types().That().Are([]).Should().BeTypesThat().Are(helper.ChildClass).AssertOnlyViolations(helper);
@@ -60,8 +61,8 @@ public async Task AreTest()
         should.BeTypesThat().Are(helper.ChildClass).AssertNoViolations(helper);
         should.BeTypesThat().Are(helper.ChildClassSystemType).AssertNoViolations(helper);
         should.BeTypesThat().Are(Classes().That().Are(helper.ChildClass)).AssertNoViolations(helper);
-        should.BeTypesThat().Are([helper.ChildClass]).AssertNoViolations(helper);
-        should.BeTypesThat().Are([helper.ChildClassSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().Are(new List<ICanBeAnalyzed> { helper.ChildClass }).AssertNoViolations(helper);
+        should.BeTypesThat().Are(new List<System.Type> { helper.ChildClassSystemType }).AssertNoViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -75,29 +76,30 @@ public async Task BeTest()
         should.Be(helper.ChildClass).AssertNoViolations(helper);
         should.Be(helper.ChildClassSystemType).AssertNoViolations(helper);
         should.Be(Classes().That().Are(helper.ChildClass)).AssertNoViolations(helper);
-        should.Be([helper.ChildClass]).AssertNoViolations(helper);
-        should.Be([helper.ChildClassSystemType]).AssertNoViolations(helper);
+        should.Be(new List<ICanBeAnalyzed> { helper.ChildClass }).AssertNoViolations(helper);
+        should.Be(new List<System.Type> { helper.ChildClassSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
         should = Types().That().Are(helper.ChildClass).Should();
         should.Be(helper.ClassWithoutDependencies).AssertOnlyViolations(helper);
         should.Be(helper.ClassWithoutDependenciesSystemType).AssertOnlyViolations(helper);
         should.Be(Classes().That().Are(helper.ClassWithoutDependencies)).AssertOnlyViolations(helper);
-        should.Be([helper.ClassWithoutDependencies]).AssertOnlyViolations(helper);
-        should.Be([helper.ClassWithoutDependenciesSystemType]).AssertOnlyViolations(helper);
+        should.Be(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies }).AssertOnlyViolations(helper);
+        should.Be(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.BaseClass).Should();
-        should.Be(new List<IType>()).AssertOnlyViolations(helper);
+        should.Be().AssertOnlyViolations(helper);
+        should.Be(new List<ICanBeAnalyzed>()).AssertOnlyViolations(helper);
         should.Be(new List<System.Type>()).AssertOnlyViolations(helper);
         should.Be(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ChildClass).Should();
         should.Be(helper.ClassWithoutDependencies, helper.BaseClass).AssertOnlyViolations(helper);
-        should.Be([helper.ClassWithoutDependencies, helper.BaseClass]).AssertOnlyViolations(helper);
+        should.Be(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertOnlyViolations(helper);
         should.Be(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertOnlyViolations(helper);
-        should.Be([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.Be(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         Types().That().Are(helper.ChildClass, helper.BaseClass).Should().Be(helper.ChildClass, helper.BaseClass).AssertNoViolations(helper);
@@ -262,17 +264,17 @@ public async Task CallAnyTest()
         
         helper.AddSnapshotSubHeader("Conditions");
         should.CallAny(helper.CalledMethod).AssertNoViolations(helper);
-        should.CallAny([helper.CalledMethod]).AssertNoViolations(helper);
+        should.CallAny(new List<MethodMember> { helper.CalledMethod }).AssertNoViolations(helper);
         should.CallAny(MethodMembers().That().Are(helper.CalledMethod)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(MethodMembers().That().CallAny(helper.CalledMethod)).AssertNoViolations(helper);
-        should.Be(MethodMembers().That().CallAny([helper.CalledMethod])).AssertNoViolations(helper);
+        should.Be(MethodMembers().That().CallAny(new List<MethodMember> { helper.CalledMethod })).AssertNoViolations(helper);
         should.Be(MethodMembers().That().CallAny(MethodMembers().That().Are(helper.CalledMethod))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeMethodMembersThat().CallAny(helper.CalledMethod).AssertNoViolations(helper);
-        should.BeMethodMembersThat().CallAny([helper.CalledMethod]).AssertNoViolations(helper);
+        should.BeMethodMembersThat().CallAny(new List<MethodMember> { helper.CalledMethod }).AssertNoViolations(helper);
         should.BeMethodMembersThat().CallAny(MethodMembers().That().Are(helper.CalledMethod)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
@@ -280,31 +282,34 @@ public async Task CallAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.CallAny(helper.CalledMethod).AssertOnlyViolations(helper);
-        should.CallAny([helper.CalledMethod]).AssertOnlyViolations(helper);
+        should.CallAny(new List<MethodMember> { helper.CalledMethod }).AssertOnlyViolations(helper);
         should.CallAny(MethodMembers().That().Are(helper.CalledMethod)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(MethodMembers().That().CallAny(helper.CalledMethod)).AssertOnlyViolations(helper);
-        should.Be(MethodMembers().That().CallAny([helper.CalledMethod])).AssertOnlyViolations(helper);
+        should.Be(MethodMembers().That().CallAny(new List<MethodMember> { helper.CalledMethod })).AssertOnlyViolations(helper);
         should.Be(MethodMembers().That().CallAny(MethodMembers().That().Are(helper.CalledMethod))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeMethodMembersThat().CallAny(helper.CalledMethod).AssertOnlyViolations(helper);
-        should.BeMethodMembersThat().CallAny([helper.CalledMethod]).AssertOnlyViolations(helper);
+        should.BeMethodMembersThat().CallAny(new List<MethodMember> { helper.CalledMethod }).AssertOnlyViolations(helper);
         should.BeMethodMembersThat().CallAny(MethodMembers().That().Are(helper.CalledMethod)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = MethodMembers().That().Are(helper.MethodWithSingleDependency).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.CallAny().AssertOnlyViolations(helper);
         should.CallAny(new List<MethodMember>()).AssertOnlyViolations(helper);
         should.CallAny(MethodMembers().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(MethodMembers().That().CallAny()).AssertOnlyViolations(helper);
         should.Be(MethodMembers().That().CallAny(new List<MethodMember>())).AssertOnlyViolations(helper);
         should.Be(MethodMembers().That().CallAny(MethodMembers().That().HaveFullName(helper.NonExistentObjectName))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeMethodMembersThat().CallAny().AssertOnlyViolations(helper);
         should.BeMethodMembersThat().CallAny(new List<MethodMember>()).AssertOnlyViolations(helper);
         should.BeMethodMembersThat().CallAny(MethodMembers().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
@@ -313,17 +318,17 @@ public async Task CallAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.CallAny(helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies).AssertOnlyViolations(helper);
-        should.CallAny([helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies]).AssertOnlyViolations(helper);
+        should.CallAny(new List<MethodMember> { helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies }).AssertOnlyViolations(helper);
         should.CallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(MethodMembers().That().CallAny(helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies)).AssertOnlyViolations(helper);
-        should.Be(MethodMembers().That().CallAny([helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies])).AssertOnlyViolations(helper);
+        should.Be(MethodMembers().That().CallAny(new List<MethodMember> { helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies })).AssertOnlyViolations(helper);
         should.Be(MethodMembers().That().CallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeMethodMembersThat().CallAny(helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies).AssertOnlyViolations(helper);
-        should.BeMethodMembersThat().CallAny([helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies]).AssertOnlyViolations(helper);
+        should.BeMethodMembersThat().CallAny(new List<MethodMember> { helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies }).AssertOnlyViolations(helper);
         should.BeMethodMembersThat().CallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies, helper.MethodWithMultipleDependencies)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Input with multiple dependencies");
@@ -356,22 +361,22 @@ public async Task DependOnAnyTest()
         should.DependOnAny(helper.BaseClass).AssertNoViolations(helper);
         should.DependOnAny(helper.BaseClassSystemType).AssertNoViolations(helper);
         should.DependOnAny(Classes().That().Are(helper.BaseClass)).AssertNoViolations(helper);
-        should.DependOnAny([helper.BaseClass]).AssertNoViolations(helper);
-        should.DependOnAny([helper.BaseClassSystemType]).AssertNoViolations(helper);
+        should.DependOnAny(new List<IType> { helper.BaseClass }).AssertNoViolations(helper);
+        should.DependOnAny(new List<System.Type> { helper.BaseClassSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DependOnAny(helper.BaseClass)).AssertNoViolations(helper);
         should.Be(Types().That().DependOnAny(helper.BaseClassSystemType)).AssertNoViolations(helper);
         should.Be(Types().That().DependOnAny(Classes().That().Are(helper.BaseClass))).AssertNoViolations(helper);
-        should.Be(Types().That().DependOnAny([helper.BaseClass])).AssertNoViolations(helper);
-        should.Be(Types().That().DependOnAny([helper.BaseClassSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<IType> { helper.BaseClass })).AssertNoViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<System.Type> { helper.BaseClassSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DependOnAny(helper.BaseClass).AssertNoViolations(helper);
         should.BeTypesThat().DependOnAny(helper.BaseClassSystemType).AssertNoViolations(helper);
         should.BeTypesThat().DependOnAny(Classes().That().Are(helper.BaseClass)).AssertNoViolations(helper);
-        should.BeTypesThat().DependOnAny([helper.BaseClass]).AssertNoViolations(helper);
-        should.BeTypesThat().DependOnAny([helper.BaseClassSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<IType> { helper.BaseClass }).AssertNoViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<System.Type> { helper.BaseClassSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
         should = Types().That().HaveFullName(helper.ClassWithMultipleDependencies.FullName).Should();
@@ -380,22 +385,22 @@ public async Task DependOnAnyTest()
         should.DependOnAny(helper.ClassWithoutDependencies).AssertOnlyViolations(helper);
         should.DependOnAny(helper.ClassWithoutDependenciesSystemType).AssertOnlyViolations(helper);
         should.DependOnAny(Classes().That().Are(helper.ClassWithoutDependencies)).AssertOnlyViolations(helper);
-        should.DependOnAny([helper.ClassWithoutDependencies]).AssertOnlyViolations(helper);
-        should.DependOnAny([helper.ClassWithoutDependenciesSystemType]).AssertOnlyViolations(helper);
+        should.DependOnAny(new List<IType> { helper.ClassWithoutDependencies }).AssertOnlyViolations(helper);
+        should.DependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DependOnAny(helper.ClassWithoutDependencies)).AssertOnlyViolations(helper);
         should.Be(Types().That().DependOnAny(helper.ClassWithoutDependenciesSystemType)).AssertOnlyViolations(helper);
         should.Be(Types().That().DependOnAny(Classes().That().Are(helper.ClassWithoutDependencies))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DependOnAny([helper.ClassWithoutDependencies])).AssertOnlyViolations(helper);
-        should.Be(Types().That().DependOnAny([helper.ClassWithoutDependenciesSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<IType> { helper.ClassWithoutDependencies })).AssertOnlyViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DependOnAny(helper.ClassWithoutDependencies).AssertOnlyViolations(helper);
         should.BeTypesThat().DependOnAny(helper.ClassWithoutDependenciesSystemType).AssertOnlyViolations(helper);
         should.BeTypesThat().DependOnAny(Classes().That().Are(helper.ClassWithoutDependencies)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DependOnAny([helper.ClassWithoutDependencies]).AssertOnlyViolations(helper);
-        should.BeTypesThat().DependOnAny([helper.ClassWithoutDependenciesSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<IType> { helper.ClassWithoutDependencies }).AssertOnlyViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ClassWithMultipleDependencies).Should();
@@ -404,25 +409,28 @@ public async Task DependOnAnyTest()
         should.DependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes))).AssertOnlyViolations(helper);
+        should.Be(Types().That().DependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes))).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertOnlyViolations(helper);
+        should.BeTypesThat().DependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithMultipleDependencies).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.DependOnAny().AssertOnlyViolations(helper);
         should.DependOnAny(new List<IType>()).AssertOnlyViolations(helper);
         should.DependOnAny(new List<System.Type>()).AssertOnlyViolations(helper);
         should.DependOnAny(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().DependOnAny()).AssertOnlyViolations(helper);
         should.Be(Types().That().DependOnAny(new List<IType>())).AssertOnlyViolations(helper);
         should.Be(Types().That().DependOnAny(new List<System.Type>())).AssertOnlyViolations(helper);
         should.Be(Types().That().DependOnAny(Classes().That().HaveFullName(helper.NonExistentObjectName))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().DependOnAny().AssertOnlyViolations(helper);
         should.BeTypesThat().DependOnAny(new List<IType>()).AssertOnlyViolations(helper);
         should.BeTypesThat().DependOnAny(new List<System.Type>()).AssertOnlyViolations(helper);
         should.BeTypesThat().DependOnAny(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
@@ -432,33 +440,33 @@ public async Task DependOnAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.DependOnAny(helper.ClassWithoutDependencies, helper.BaseClass).AssertOnlyViolations(helper);
-        should.DependOnAny([helper.ClassWithoutDependencies, helper.BaseClass]).AssertOnlyViolations(helper);
+        should.DependOnAny(new List<IType> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertOnlyViolations(helper);
         should.DependOnAny(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertOnlyViolations(helper);
-        should.DependOnAny([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.DependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DependOnAny(helper.ClassWithoutDependencies, helper.BaseClass)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DependOnAny([helper.ClassWithoutDependencies, helper.BaseClass])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<IType> { helper.ClassWithoutDependencies, helper.BaseClass })).AssertOnlyViolations(helper);
         should.Be(Types().That().DependOnAny(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DependOnAny([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DependOnAny(helper.ClassWithoutDependencies, helper.BaseClass).AssertOnlyViolations(helper);
-        should.BeTypesThat().DependOnAny([helper.ClassWithoutDependencies, helper.BaseClass]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<IType> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertOnlyViolations(helper);
         should.BeTypesThat().DependOnAny(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DependOnAny([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Input without dependencies");
         should = Types().That().Are(helper.ClassWithoutDependencies).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.DependOnAny([helper.BaseClass, helper.ChildClass]).AssertOnlyViolations(helper);
+        should.DependOnAny(new List<IType> { helper.BaseClass, helper.ChildClass }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DependOnAny([helper.BaseClass, helper.ChildClass])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DependOnAny(new List<IType> { helper.BaseClass, helper.ChildClass })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DependOnAny([helper.BaseClass, helper.ChildClass]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DependOnAny(new List<IType> { helper.BaseClass, helper.ChildClass }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
 
@@ -593,23 +601,23 @@ public async Task HaveAnyAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributes(helper.Attribute1).AssertNoViolations(helper);
-        should.HaveAnyAttributes([helper.Attribute1]).AssertNoViolations(helper);
+        should.HaveAnyAttributes(new List<Attribute> { helper.Attribute1 }).AssertNoViolations(helper);
         should.HaveAnyAttributes(helper.Attribute1SystemType).AssertNoViolations(helper);
-        should.HaveAnyAttributes([helper.Attribute1SystemType]).AssertNoViolations(helper);
+        should.HaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType }).AssertNoViolations(helper);
         should.HaveAnyAttributes(Attributes().That().Are(helper.Attribute1)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributes(helper.Attribute1)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributes([helper.Attribute1])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributes(new List<Attribute> { helper.Attribute1 })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(helper.Attribute1SystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributes([helper.Attribute1SystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(Attributes().That().Are(helper.Attribute1))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributes(helper.Attribute1).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributes([helper.Attribute1]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributes(new List<Attribute> { helper.Attribute1 }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(helper.Attribute1SystemType).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributes([helper.Attribute1SystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(Attributes().That().Are(helper.Attribute1)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
@@ -617,39 +625,42 @@ public async Task HaveAnyAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributes(helper.UnusedAttribute).AssertOnlyViolations(helper);
-        should.HaveAnyAttributes([helper.UnusedAttribute]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributes(new List<Attribute> { helper.UnusedAttribute }).AssertOnlyViolations(helper);
         should.HaveAnyAttributes(helper.UnusedAttributeSystemType).AssertOnlyViolations(helper);
-        should.HaveAnyAttributes([helper.UnusedAttributeSystemType]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributes(new List<System.Type> { helper.UnusedAttributeSystemType }).AssertOnlyViolations(helper);
         should.HaveAnyAttributes(Attributes().That().Are(helper.UnusedAttribute)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributes(helper.UnusedAttribute)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributes([helper.UnusedAttribute])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributes(new List<Attribute> { helper.UnusedAttribute })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(helper.UnusedAttributeSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributes([helper.UnusedAttributeSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributes(new List<System.Type> { helper.UnusedAttributeSystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(Attributes().That().Are(helper.UnusedAttribute))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributes(helper.UnusedAttribute).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributes([helper.UnusedAttribute]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributes(new List<Attribute> { helper.UnusedAttribute }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(helper.UnusedAttributeSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributes([helper.UnusedAttributeSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributes(new List<System.Type> { helper.UnusedAttributeSystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(Attributes().That().Are(helper.UnusedAttribute)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithTwoAttributes).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.HaveAnyAttributes();
         should.HaveAnyAttributes(new List<Attribute>()).AssertOnlyViolations(helper);
         should.HaveAnyAttributes(new List<System.Type>()).AssertOnlyViolations(helper);
         should.HaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().HaveAnyAttributes()).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(new List<Attribute>())).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(new List<System.Type>())).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().HaveAnyAttributes().AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(new List<Attribute>()).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(new List<System.Type>()).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
@@ -659,23 +670,23 @@ public async Task HaveAnyAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributes(helper.Attribute1, helper.UnusedAttribute).AssertNoViolations(helper);
-        should.HaveAnyAttributes([helper.Attribute1, helper.UnusedAttribute]).AssertNoViolations(helper);
+        should.HaveAnyAttributes(new List<Attribute> { helper.Attribute1, helper.UnusedAttribute }).AssertNoViolations(helper);
         should.HaveAnyAttributes(helper.Attribute1SystemType, helper.UnusedAttributeSystemType).AssertNoViolations(helper);
-        should.HaveAnyAttributes([helper.Attribute1SystemType, helper.UnusedAttributeSystemType]).AssertNoViolations(helper);
+        should.HaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.UnusedAttributeSystemType }).AssertNoViolations(helper);
         should.HaveAnyAttributes(Attributes().That().Are(helper.Attribute1, helper.UnusedAttribute)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributes(helper.Attribute1, helper.UnusedAttribute)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributes([helper.Attribute1, helper.UnusedAttribute])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributes(new List<Attribute> { helper.Attribute1, helper.UnusedAttribute })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(helper.Attribute1SystemType, helper.UnusedAttributeSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributes([helper.Attribute1SystemType, helper.UnusedAttributeSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.UnusedAttributeSystemType })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAnyAttributes(Attributes().That().Are(helper.Attribute1, helper.UnusedAttribute))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributes(helper.Attribute1, helper.UnusedAttribute).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributes([helper.Attribute1, helper.UnusedAttribute]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributes(new List<Attribute> { helper.Attribute1, helper.UnusedAttribute }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(helper.Attribute1SystemType, helper.UnusedAttributeSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributes([helper.Attribute1SystemType, helper.UnusedAttributeSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.UnusedAttributeSystemType }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAnyAttributes(Attributes().That().Are(helper.Attribute1, helper.UnusedAttribute)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
@@ -719,60 +730,60 @@ public async Task HaveAnyAttributesWithArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithArguments(helper.Attribute1TypeArgumentSystemType).AssertNoViolations(helper);
-        should.HaveAnyAttributesWithArguments([helper.Attribute1TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithArguments(helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithArguments([helper.Attribute1TypeArgumentSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithArguments(helper.Attribute1TypeArgumentSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithArguments([helper.Attribute1TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument).AssertNoViolations(helper);
-        should.HaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument]).AssertNoViolations(helper);
+        should.HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithArguments(helper.UnusedTypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithArguments([helper.UnusedTypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithArguments(helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithArguments([helper.UnusedTypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgumentSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithArguments(helper.UnusedTypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithArguments([helper.UnusedTypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithoutAttributes).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Null argument");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
@@ -789,30 +800,30 @@ public async Task HaveAnyAttributesWithArgumentsTest()
         helper.AddSnapshotHeader("Empty arguments");
 
         helper.AddSnapshotSubHeader("Conditions");
-        Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should().HaveAnyAttributesWithArguments([]).AssertNoViolations(helper);
-        Types().That().Are(helper.ClassWithTwoAttributesWithArguments).Should().HaveAnyAttributesWithArguments([]).AssertNoViolations(helper);
+        Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should().HaveAnyAttributesWithArguments(new List<object>()).AssertNoViolations(helper);
+        Types().That().Are(helper.ClassWithTwoAttributesWithArguments).Should().HaveAnyAttributesWithArguments(new List<object>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should().Be(Types().That().HaveAnyAttributesWithArguments([])).AssertNoViolations(helper);
-        Types().That().Are(helper.ClassWithTwoAttributesWithArguments).Should().Be(Types().That().HaveAnyAttributesWithArguments([])).AssertNoViolations(helper);
+        Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should().Be(Types().That().HaveAnyAttributesWithArguments(new List<object>())).AssertNoViolations(helper);
+        Types().That().Are(helper.ClassWithTwoAttributesWithArguments).Should().Be(Types().That().HaveAnyAttributesWithArguments(new List<object>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should().BeTypesThat().HaveAnyAttributesWithArguments([]).AssertNoViolations(helper);
-        Types().That().Are(helper.ClassWithTwoAttributesWithArguments).Should().BeTypesThat().HaveAnyAttributesWithArguments([]).AssertNoViolations(helper);
+        Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should().BeTypesThat().HaveAnyAttributesWithArguments(new List<object>()).AssertNoViolations(helper);
+        Types().That().Are(helper.ClassWithTwoAttributesWithArguments).Should().BeTypesThat().HaveAnyAttributesWithArguments(new List<object>()).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.HaveAnyAttributesWithArguments([helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithArguments(new List<object> { helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue }).AssertOnlyViolations(helper);
         should.HaveAnyAttributesWithArguments(helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().HaveAnyAttributesWithArguments([helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithArguments(new List<object> { helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributesWithArguments(helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().HaveAnyAttributesWithArguments([helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithArguments(new List<object> { helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributesWithArguments(helper.UnusedAttributeIntValue, helper.UnusedAttributeStringValue).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
@@ -842,141 +853,141 @@ public async Task HaveAnyAttributesWithNamedArguments()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations for attribute without named arguments");
         should = Types().That().Are(helper.ClassWithSingleAttribute).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.UnusedTypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.UnusedTypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.UnusedAttributeStringValue)]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.UnusedAttributeStringValue))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.UnusedAttributeStringValue)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.UnusedAttributeStringValue)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.HaveAnyAttributesWithNamedArguments([]).AssertNoViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)>()).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertNoViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue),]).AssertOnlyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument),])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue),])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue),]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments, helper.ClassWithTwoAttributesWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.HaveAnyAttributesWithNamedArguments([("NamedParameter3", helper.Attribute2TypeArgumentSystemType)]).AssertAnyViolations(helper);
+        should.HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) }).AssertAnyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAnyAttributesWithNamedArguments([("NamedParameter3", helper.Attribute2TypeArgumentSystemType)])).AssertAnyViolations(helper);
+        should.Be(Types().That().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) })).AssertAnyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAnyAttributesWithNamedArguments([("NamedParameter3", helper.Attribute2TypeArgumentSystemType)]).AssertAnyViolations(helper);
+        should.BeTypesThat().HaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) }).AssertAnyViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -991,105 +1002,105 @@ public async Task HaveAttributeWithArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType).AssertNoViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertNoViolations(helper);
         should.HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType).AssertNoViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
         should.HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations for wrong attribute");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithArguments(helper.UnusedAttribute, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.HaveAttributeWithArguments(helper.UnusedAttribute, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithArguments(helper.UnusedAttribute, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
         should.HaveAttributeWithArguments(helper.UnusedAttributeSystemType, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.HaveAttributeWithArguments(helper.UnusedAttributeSystemType, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithArguments(helper.UnusedAttributeSystemType, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithArguments(helper.UnusedAttribute, helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.UnusedAttribute, [helper.Attribute1TypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.UnusedAttribute, new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithArguments(helper.UnusedAttributeSystemType, helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.UnusedAttributeSystemType, [helper.Attribute1TypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.UnusedAttributeSystemType, new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithArguments(helper.UnusedAttribute, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.UnusedAttribute, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.UnusedAttribute, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithArguments(helper.UnusedAttributeSystemType, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.UnusedAttributeSystemType, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.UnusedAttributeSystemType, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithArguments(helper.Attribute1, helper.UnusedTypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1, [helper.UnusedTypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.UnusedTypeArgumentSystemType }).AssertOnlyViolations(helper);
         should.HaveAttributeWithArguments(helper.Attribute1SystemType, helper.UnusedTypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.UnusedTypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.UnusedTypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, [helper.UnusedTypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.UnusedTypeArgumentSystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.UnusedTypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.UnusedTypeArgumentSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, helper.UnusedTypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, [helper.UnusedTypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.UnusedTypeArgumentSystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.UnusedTypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.UnusedTypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.UnusedTypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithArguments(helper.Attribute1, helper.Attribute2StringArgument).AssertOnlyViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2StringArgument]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2StringArgument }).AssertOnlyViolations(helper);
         should.HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2StringArgument).AssertOnlyViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2StringArgument]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2StringArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute2StringArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2StringArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2StringArgument })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2StringArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2StringArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2StringArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute2StringArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2StringArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2StringArgument }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2StringArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2StringArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2StringArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
@@ -1138,21 +1149,21 @@ public async Task HaveAttributeWithArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument, helper.Attribute1IntegerArgument).AssertNoViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument, helper.Attribute1IntegerArgument]).AssertNoViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument, helper.Attribute1IntegerArgument }).AssertNoViolations(helper);
         should.HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument, helper.Attribute1IntegerArgument).AssertNoViolations(helper);
-        should.HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument, helper.Attribute1IntegerArgument]).AssertNoViolations(helper);
+        should.HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument, helper.Attribute1IntegerArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument, helper.Attribute1IntegerArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument, helper.Attribute1IntegerArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument, helper.Attribute1IntegerArgument })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument, helper.Attribute1IntegerArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument, helper.Attribute1IntegerArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument, helper.Attribute1IntegerArgument })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument, helper.Attribute1IntegerArgument).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument, helper.Attribute1IntegerArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument, helper.Attribute1IntegerArgument }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument, helper.Attribute1IntegerArgument).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument, helper.Attribute1IntegerArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument, helper.Attribute1IntegerArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments, helper.ClassWithTwoAttributesWithArguments).Should();
@@ -1182,132 +1193,132 @@ public async Task HaveAttributeWithNamedArguments()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
-        
+        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
+
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute1StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute1StringArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertNoViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute1StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute1StringArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations for attribute without named arguments");
         should = Types().That().Are(helper.ClassWithSingleAttribute).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("InvalidName", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("InvalidName", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("InvalidName", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("InvalidName", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.UnusedTypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.UnusedTypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.UnusedTypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.UnusedTypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("InvalidName", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("InvalidName", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("InvalidName", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("InvalidName", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.UnusedAttributeStringValue)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("InvalidName", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("InvalidName", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.UnusedAttributeStringValue))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.UnusedAttributeStringValue)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("InvalidName", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("InvalidName", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.UnusedAttributeStringValue)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.UnusedAttributeStringValue)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Unused attribute");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.UnusedAttribute, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.UnusedAttribute, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.UnusedAttribute, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertOnlyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.UnusedAttribute, ("NamedParameter1", helper.Attribute1TypeArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.UnusedAttribute, [("NamedParameter1", helper.Attribute1TypeArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.UnusedAttribute, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, ("NamedParameter1", helper.Attribute1TypeArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, [("NamedParameter1", helper.Attribute1TypeArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.UnusedAttribute, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.UnusedAttribute, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.UnusedAttribute, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
@@ -1325,58 +1336,58 @@ public async Task HaveAttributeWithNamedArguments()
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, []).AssertNoViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, []).AssertNoViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)>()).AssertNoViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [])).AssertNoViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [])).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)>())).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, []).AssertNoViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, []).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)>()).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)>()).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),])).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments, helper.ClassWithTwoAttributesWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveAttributeWithNamedArguments(helper.Attribute2, ("NamedParameter3", helper.Attribute2TypeArgumentSystemType)).AssertAnyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute2, [("NamedParameter3", helper.Attribute2TypeArgumentSystemType)]).AssertAnyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute2, new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) }).AssertAnyViolations(helper);
         should.HaveAttributeWithNamedArguments(helper.Attribute2SystemType, ("NamedParameter3", helper.Attribute2TypeArgumentSystemType)).AssertAnyViolations(helper);
-        should.HaveAttributeWithNamedArguments(helper.Attribute2SystemType, [("NamedParameter3", helper.Attribute2TypeArgumentSystemType)]).AssertAnyViolations(helper);
+        should.HaveAttributeWithNamedArguments(helper.Attribute2SystemType, new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) }).AssertAnyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute2, ("NamedParameter3", helper.Attribute2TypeArgumentSystemType))).AssertAnyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute2, [("NamedParameter3", helper.Attribute2TypeArgumentSystemType)])).AssertAnyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute2, new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) })).AssertAnyViolations(helper);
         should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute2SystemType, ("NamedParameter3", helper.Attribute2TypeArgumentSystemType))).AssertAnyViolations(helper);
-        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute2SystemType, [("NamedParameter3", helper.Attribute2TypeArgumentSystemType)])).AssertAnyViolations(helper);
+        should.Be(Types().That().HaveAttributeWithNamedArguments(helper.Attribute2SystemType, new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) })).AssertAnyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute2, ("NamedParameter3", helper.Attribute2TypeArgumentSystemType)).AssertAnyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute2, [("NamedParameter3", helper.Attribute2TypeArgumentSystemType)]).AssertAnyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute2, new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) }).AssertAnyViolations(helper);
         should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute2SystemType, ("NamedParameter3", helper.Attribute2TypeArgumentSystemType)).AssertAnyViolations(helper);
-        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute2SystemType, [("NamedParameter3", helper.Attribute2TypeArgumentSystemType)]).AssertAnyViolations(helper);
+        should.BeTypesThat().HaveAttributeWithNamedArguments(helper.Attribute2SystemType, new List<(string, object)> { ("NamedParameter3", helper.Attribute2TypeArgumentSystemType) }).AssertAnyViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -1391,32 +1402,53 @@ public async Task HaveNameTest()
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveName(helper.BaseClass.Name).AssertNoViolations(helper);
         should.HaveNameMatching("^Base.*$").AssertNoViolations(helper);
+        should.HaveNameStartingWith("Base").AssertNoViolations(helper);
+        should.HaveNameEndingWith("Class").AssertNoViolations(helper);
+        should.HaveNameContaining("Base").AssertNoViolations(helper);
         should.HaveFullName(helper.BaseClass.FullName).AssertNoViolations(helper);
         should.HaveFullNameMatching("^.*\\.Base.*$").AssertNoViolations(helper);
-        should.HaveNameContaining("Base").AssertNoViolations(helper);
+        should.HaveFullNameStartingWith(helper.BaseClass.Namespace.FullName).AssertNoViolations(helper);
+        should.HaveFullNameEndingWith("BaseClass").AssertNoViolations(helper);
         should.HaveFullNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
-        should.HaveNameStartingWith("Base").AssertNoViolations(helper);
-        should.HaveNameEndingWith("Class").AssertNoViolations(helper);
+        should.HaveAssemblyQualifiedName(helper.BaseClass.AssemblyQualifiedName).AssertNoViolations(helper);
+        should.HaveAssemblyQualifiedNameMatching($"^{helper.BaseClass.FullName}, .*{helper.BaseClass.Assembly.Name}.*$").AssertNoViolations(helper);
+        should.HaveAssemblyQualifiedNameStartingWith(helper.BaseClass.FullName).AssertNoViolations(helper);
+        should.HaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Assembly.FullName).AssertNoViolations(helper);
+        should.HaveAssemblyQualifiedNameContaining(helper.BaseClass.Assembly.Name).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().HaveName(helper.BaseClass.Name)).AssertNoViolations(helper);
         should.Be(Types().That().HaveNameMatching("^Base.*$")).AssertNoViolations(helper);
+        should.Be(Types().That().HaveNameStartingWith("Base")).AssertNoViolations(helper);
+        should.Be(Types().That().HaveNameEndingWith("Class")).AssertNoViolations(helper);
+        should.Be(Types().That().HaveNameContaining("Base")).AssertNoViolations(helper);
         should.Be(Types().That().HaveFullName(helper.BaseClass.FullName)).AssertNoViolations(helper);
         should.Be(Types().That().HaveFullNameMatching("^.*\\.Base.*$")).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameContaining("Base")).AssertNoViolations(helper);
+        should.Be(Types().That().HaveFullNameStartingWith(helper.BaseClass.Namespace.FullName)).AssertNoViolations(helper);
+        should.Be(Types().That().HaveFullNameEndingWith("BaseClass")).AssertNoViolations(helper);
         should.Be(Types().That().HaveFullNameContaining(helper.BaseClass.Namespace.Name)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameStartingWith("Base")).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameEndingWith("Class")).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedName(helper.BaseClass.AssemblyQualifiedName)).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameMatching($"^{helper.BaseClass.FullName}, .*{helper.BaseClass.Assembly.Name}.*$")).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameStartingWith(helper.BaseClass.FullName)).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Assembly.FullName)).AssertNoViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameContaining(helper.BaseClass.Assembly.Name)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().HaveName(helper.BaseClass.Name).AssertNoViolations(helper);
         should.BeTypesThat().HaveNameMatching("^Base.*$").AssertNoViolations(helper);
+        should.BeTypesThat().HaveNameStartingWith("Base").AssertNoViolations(helper);
+        should.BeTypesThat().HaveNameEndingWith("Class").AssertNoViolations(helper);
+        should.BeTypesThat().HaveNameContaining("Base").AssertNoViolations(helper);
         should.BeTypesThat().HaveFullName(helper.BaseClass.FullName).AssertNoViolations(helper);
         should.BeTypesThat().HaveFullNameMatching("^.*\\.Base.*$").AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameContaining("Base").AssertNoViolations(helper);
+        should.BeTypesThat().HaveFullNameStartingWith(helper.BaseClass.Namespace.FullName).AssertNoViolations(helper);
+        should.BeTypesThat().HaveFullNameEndingWith("BaseClass").AssertNoViolations(helper);
         should.BeTypesThat().HaveFullNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameStartingWith("Base").AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameEndingWith("Class").AssertNoViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedName(helper.BaseClass.AssemblyQualifiedName).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameMatching($"^{helper.BaseClass.FullName}, .*{helper.BaseClass.Assembly.Name}.*$").AssertNoViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameStartingWith(helper.BaseClass.FullName).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Assembly.FullName).AssertNoViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameContaining(helper.BaseClass.Assembly.Name).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
         should = Types().That().Are(helper.BaseClass).Should();
@@ -1424,33 +1456,54 @@ public async Task HaveNameTest()
         helper.AddSnapshotSubHeader("Conditions");
         should.HaveName(helper.BaseClass.FullName).AssertOnlyViolations(helper);
         should.HaveName("^.*\\.Base.*$").AssertOnlyViolations(helper);
+        should.HaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.HaveNameEndingWith("Base").AssertOnlyViolations(helper);
+        should.HaveNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
         should.HaveFullName(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.HaveFullName("^Base.*$").AssertOnlyViolations(helper);
-        should.HaveNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.HaveFullNameStartingWith("Base").AssertOnlyViolations(helper);
+        should.HaveFullNameEndingWith(helper.BaseClass.Namespace.FullName).AssertOnlyViolations(helper);
         should.HaveFullNameContaining(helper.NonExistentObjectName).AssertOnlyViolations(helper);
-        should.HaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
-        should.HaveNameEndingWith("Base").AssertOnlyViolations(helper);
-
-        helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().HaveName(helper.BaseClass.Name)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameMatching("^Base.*$")).AssertNoViolations(helper);
-        should.Be(Types().That().HaveFullName(helper.BaseClass.FullName)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveFullNameMatching("^.*\\.Base.*$")).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameContaining("Base")).AssertNoViolations(helper);
-        should.Be(Types().That().HaveFullNameContaining(helper.BaseClass.Namespace.Name)).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameStartingWith("Base")).AssertNoViolations(helper);
-        should.Be(Types().That().HaveNameEndingWith("Class")).AssertNoViolations(helper);
-
+        should.HaveAssemblyQualifiedName(helper.BaseClass.FullName).AssertOnlyViolations(helper);
+        should.HaveAssemblyQualifiedName($"^{helper.BaseClass.FullName}, .*{helper.NonExistentObjectName}.*$").AssertOnlyViolations(helper);
+        should.HaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.HaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Namespace.FullName).AssertOnlyViolations(helper);
+        should.HaveAssemblyQualifiedNameContaining(helper.NonExistentObjectName).AssertOnlyViolations(helper);
+
+        helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().HaveName(helper.BaseClass.FullName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveName("^.*\\.Base.*$")).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveNameStartingWith(helper.BaseClass.Namespace.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveNameEndingWith("Base")).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveNameContaining(helper.BaseClass.Namespace.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveFullName(helper.BaseClass.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveFullName("^Base.*$")).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveFullNameStartingWith("Base")).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveFullNameEndingWith(helper.BaseClass.Namespace.FullName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveFullNameContaining(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedName(helper.BaseClass.FullName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedName($"^{helper.BaseClass.FullName}, .*{helper.NonExistentObjectName}.*$")).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Namespace.FullName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().HaveAssemblyQualifiedNameContaining(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
+        
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().HaveName(helper.BaseClass.Name).AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameMatching("^Base.*$").AssertNoViolations(helper);
-        should.BeTypesThat().HaveFullName(helper.BaseClass.FullName).AssertNoViolations(helper);
-        should.BeTypesThat().HaveFullNameMatching("^.*\\.Base.*$").AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameContaining("Base").AssertNoViolations(helper);
-        should.BeTypesThat().HaveFullNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameStartingWith("Base").AssertNoViolations(helper);
-        should.BeTypesThat().HaveNameEndingWith("Class").AssertNoViolations(helper);
-
+        should.BeTypesThat().HaveName(helper.BaseClass.FullName).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveName("^.*\\.Base.*$").AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveNameEndingWith("Base").AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveFullName(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveFullName("^Base.*$").AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveFullNameStartingWith("Base").AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveFullNameEndingWith(helper.BaseClass.Namespace.FullName).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveFullNameContaining(helper.NonExistentObjectName).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedName(helper.BaseClass.FullName).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedName($"^{helper.BaseClass.FullName}, .*{helper.NonExistentObjectName}.*$").AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Namespace.FullName).AssertOnlyViolations(helper);
+        should.BeTypesThat().HaveAssemblyQualifiedNameContaining(helper.NonExistentObjectName).AssertOnlyViolations(helper);
+        
         await helper.AssertSnapshotMatches();
     }
 
@@ -1466,22 +1519,22 @@ public async Task NotBeTest()
         should.NotBe(helper.ClassWithoutDependencies).AssertNoViolations(helper);
         should.NotBe(helper.ClassWithoutDependenciesSystemType).AssertNoViolations(helper);
         should.NotBe(Classes().That().Are(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
-        should.NotBe([helper.ClassWithoutDependencies]).AssertNoViolations(helper);
-        should.NotBe([helper.ClassWithoutDependenciesSystemType]).AssertNoViolations(helper);
+        should.NotBe(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies }).AssertNoViolations(helper);
+        should.NotBe(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().AreNot(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
         should.Be(Types().That().AreNot(helper.ClassWithoutDependenciesSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().AreNot(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
-        should.Be(Types().That().AreNot([helper.ClassWithoutDependencies])).AssertNoViolations(helper);
-        should.Be(Types().That().AreNot([helper.ClassWithoutDependenciesSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().AreNot(Classes().That().Are(helper.ClassWithoutDependencies))).AssertNoViolations(helper);
+        should.Be(Types().That().AreNot(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies })).AssertNoViolations(helper);
+        should.Be(Types().That().AreNot(new List<System.Type> { helper.ClassWithoutDependenciesSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().AreNot(helper.ClassWithoutDependencies).AssertNoViolations(helper);
         should.BeTypesThat().AreNot(helper.ClassWithoutDependenciesSystemType).AssertNoViolations(helper);
         should.BeTypesThat().AreNot(Classes().That().Are(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
-        should.BeTypesThat().AreNot([helper.ClassWithoutDependencies]).AssertNoViolations(helper);
-        should.BeTypesThat().AreNot([helper.ClassWithoutDependenciesSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().AreNot(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies }).AssertNoViolations(helper);
+        should.BeTypesThat().AreNot(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
         should = Types().That().DependOnAny(helper.BaseClass).Should();
@@ -1490,37 +1543,40 @@ public async Task NotBeTest()
         should.NotBe(helper.ChildClass).AssertAnyViolations(helper);
         should.NotBe(helper.ChildClassSystemType).AssertAnyViolations(helper);
         should.NotBe(Classes().That().Are(helper.ChildClass)).AssertAnyViolations(helper);
-        should.NotBe([helper.ChildClass]).AssertAnyViolations(helper);
-        should.NotBe([helper.ChildClassSystemType]).AssertAnyViolations(helper);
+        should.NotBe(new List<ICanBeAnalyzed> { helper.ChildClass }).AssertAnyViolations(helper);
+        should.NotBe(new List<System.Type> { helper.ChildClassSystemType }).AssertAnyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().AreNot(helper.ChildClass)).AssertAnyViolations(helper);
         should.Be(Types().That().AreNot(helper.ChildClassSystemType)).AssertAnyViolations(helper);
         should.Be(Types().That().AreNot(Classes().That().Are(helper.ChildClass))).AssertAnyViolations(helper);
-        should.Be(Types().That().AreNot([helper.ChildClass])).AssertAnyViolations(helper);
-        should.Be(Types().That().AreNot([helper.ChildClassSystemType])).AssertAnyViolations(helper);
+        should.Be(Types().That().AreNot(new List<ICanBeAnalyzed> { helper.ChildClass })).AssertAnyViolations(helper);
+        should.Be(Types().That().AreNot(new List<System.Type> { helper.ChildClassSystemType })).AssertAnyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().AreNot(helper.ChildClass).AssertAnyViolations(helper);
         should.BeTypesThat().AreNot(helper.ChildClassSystemType).AssertAnyViolations(helper);
         should.BeTypesThat().AreNot(Classes().That().Are(helper.ChildClass)).AssertAnyViolations(helper);
-        should.BeTypesThat().AreNot([helper.ChildClass]).AssertAnyViolations(helper);
-        should.BeTypesThat().AreNot([helper.ChildClassSystemType]).AssertAnyViolations(helper);
+        should.BeTypesThat().AreNot(new List<ICanBeAnalyzed> { helper.ChildClass }).AssertAnyViolations(helper);
+        should.BeTypesThat().AreNot(new List<System.Type> { helper.ChildClassSystemType }).AssertAnyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().DependOnAny(helper.BaseClass).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.NotBe().AssertNoViolations(helper);
         should.NotBe(new List<IType>()).AssertNoViolations(helper);
         should.NotBe(new List<System.Type>()).AssertNoViolations(helper);
         should.NotBe(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().AreNot()).AssertNoViolations(helper);
         should.Be(Types().That().AreNot(new List<IType>())).AssertNoViolations(helper);
         should.Be(Types().That().AreNot(new List<System.Type>())).AssertNoViolations(helper);
         should.Be(Types().That().AreNot(Classes().That().HaveFullName(helper.NonExistentObjectName))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().AreNot().AssertNoViolations(helper);
         should.BeTypesThat().AreNot(new List<IType>()).AssertNoViolations(helper);
         should.BeTypesThat().AreNot(new List<System.Type>()).AssertNoViolations(helper);
         should.BeTypesThat().AreNot(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertNoViolations(helper);
@@ -1530,21 +1586,21 @@ public async Task NotBeTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotBe(helper.ClassWithoutDependencies, helper.BaseClass).AssertNoViolations(helper);
-        should.NotBe([helper.ClassWithoutDependencies, helper.BaseClass]).AssertNoViolations(helper);
+        should.NotBe(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertNoViolations(helper);
         should.NotBe(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertNoViolations(helper);
-        should.NotBe([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertNoViolations(helper);
+        should.NotBe(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().AreNot(helper.ClassWithoutDependencies, helper.BaseClass)).AssertNoViolations(helper);
-        should.Be(Types().That().AreNot([helper.ClassWithoutDependencies, helper.BaseClass])).AssertNoViolations(helper);
+        should.Be(Types().That().AreNot(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies, helper.BaseClass })).AssertNoViolations(helper);
         should.Be(Types().That().AreNot(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().AreNot([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().AreNot(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().AreNot(helper.ClassWithoutDependencies, helper.BaseClass).AssertNoViolations(helper);
-        should.BeTypesThat().AreNot([helper.ClassWithoutDependencies, helper.BaseClass]).AssertNoViolations(helper);
+        should.BeTypesThat().AreNot(new List<ICanBeAnalyzed> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertNoViolations(helper);
         should.BeTypesThat().AreNot(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().AreNot([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().AreNot(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertNoViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -1559,17 +1615,17 @@ public async Task NotCallAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotCallAny(helper.MethodWithoutDependencies).AssertNoViolations(helper);
-        should.NotCallAny([helper.MethodWithoutDependencies]).AssertNoViolations(helper);
+        should.NotCallAny(new List<MethodMember> { helper.MethodWithoutDependencies }).AssertNoViolations(helper);
         should.NotCallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(MethodMembers().That().DoNotCallAny(helper.MethodWithoutDependencies)).AssertNoViolations(helper);
-        should.Be(MethodMembers().That().DoNotCallAny([helper.MethodWithoutDependencies])).AssertNoViolations(helper);
+        should.Be(MethodMembers().That().DoNotCallAny(new List<MethodMember> { helper.MethodWithoutDependencies })).AssertNoViolations(helper);
         should.Be(MethodMembers().That().DoNotCallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeMethodMembersThat().DoNotCallAny(helper.MethodWithoutDependencies).AssertNoViolations(helper);
-        should.BeMethodMembersThat().DoNotCallAny([helper.MethodWithoutDependencies]).AssertNoViolations(helper);
+        should.BeMethodMembersThat().DoNotCallAny(new List<MethodMember> { helper.MethodWithoutDependencies }).AssertNoViolations(helper);
         should.BeMethodMembersThat().DoNotCallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
@@ -1577,29 +1633,32 @@ public async Task NotCallAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotCallAny(helper.CalledMethod).AssertOnlyViolations(helper);
-        should.NotCallAny([helper.CalledMethod]).AssertOnlyViolations(helper);
+        should.NotCallAny(new List<MethodMember> { helper.CalledMethod }).AssertOnlyViolations(helper);
         should.NotCallAny(MethodMembers().That().Are(helper.CalledMethod)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(MethodMembers().That().DoNotCallAny(helper.CalledMethod)).AssertOnlyViolations(helper);
-        should.Be(MethodMembers().That().DoNotCallAny([helper.CalledMethod])).AssertOnlyViolations(helper);
+        should.Be(MethodMembers().That().DoNotCallAny(new List<MethodMember> { helper.CalledMethod })).AssertOnlyViolations(helper);
         should.Be(MethodMembers().That().DoNotCallAny(MethodMembers().That().Are(helper.CalledMethod))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeMethodMembersThat().DoNotCallAny(helper.CalledMethod).AssertOnlyViolations(helper);
-        should.BeMethodMembersThat().DoNotCallAny([helper.CalledMethod]).AssertOnlyViolations(helper);
+        should.BeMethodMembersThat().DoNotCallAny(new List<MethodMember> { helper.CalledMethod }).AssertOnlyViolations(helper);
         should.BeMethodMembersThat().DoNotCallAny(MethodMembers().That().Are(helper.CalledMethod)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = MethodMembers().That().Are(helper.MethodWithSingleDependency).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.NotCallAny();
         should.NotCallAny(new List<MethodMember>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(MethodMembers().That().DoNotCallAny()).AssertNoViolations(helper);
         should.Be(MethodMembers().That().DoNotCallAny(new List<MethodMember>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeMethodMembersThat().DoNotCallAny().AssertNoViolations(helper);
         should.BeMethodMembersThat().DoNotCallAny(new List<MethodMember>()).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
@@ -1607,17 +1666,17 @@ public async Task NotCallAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotCallAny(helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2).AssertOnlyViolations(helper);
-        should.NotCallAny([helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2]).AssertOnlyViolations(helper);
+        should.NotCallAny(new List<MethodMember> { helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2 }).AssertOnlyViolations(helper);
         should.NotCallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(MethodMembers().That().DoNotCallAny(helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2)).AssertOnlyViolations(helper);
-        should.Be(MethodMembers().That().DoNotCallAny([helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2])).AssertOnlyViolations(helper);
+        should.Be(MethodMembers().That().DoNotCallAny(new List<MethodMember> { helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2 })).AssertOnlyViolations(helper);
         should.Be(MethodMembers().That().DoNotCallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeMethodMembersThat().DoNotCallAny(helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2).AssertOnlyViolations(helper);
-        should.BeMethodMembersThat().DoNotCallAny([helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2]).AssertOnlyViolations(helper);
+        should.BeMethodMembersThat().DoNotCallAny(new List<MethodMember> { helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2 }).AssertOnlyViolations(helper);
         should.BeMethodMembersThat().DoNotCallAny(MethodMembers().That().Are(helper.MethodWithoutDependencies, helper.CalledMethod1, helper.CalledMethod2)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
@@ -1662,22 +1721,22 @@ public async Task NotDependOnAnyTest()
         should.NotDependOnAny(helper.ClassWithoutDependencies).AssertNoViolations(helper);
         should.NotDependOnAny(helper.ClassWithoutDependenciesSystemType).AssertNoViolations(helper);
         should.NotDependOnAny(Classes().That().Are(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
-        should.NotDependOnAny([helper.ClassWithoutDependencies]).AssertNoViolations(helper);
-        should.NotDependOnAny([helper.ClassWithoutDependenciesSystemType]).AssertNoViolations(helper);
+        should.NotDependOnAny(new List<IType> { helper.ClassWithoutDependencies }).AssertNoViolations(helper);
+        should.NotDependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotDependOnAny(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
         should.Be(Types().That().DoNotDependOnAny(helper.ClassWithoutDependenciesSystemType)).AssertNoViolations(helper);
         should.Be(Types().That().DoNotDependOnAny(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotDependOnAny([helper.ClassWithoutDependencies])).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotDependOnAny([helper.ClassWithoutDependenciesSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(new List<IType> { helper.ClassWithoutDependencies })).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotDependOnAny(helper.ClassWithoutDependencies).AssertNoViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(helper.ClassWithoutDependenciesSystemType).AssertNoViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(Classes().That().Are(helper.ClassWithoutDependencies)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.ClassWithoutDependencies]).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.ClassWithoutDependenciesSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<IType> { helper.ClassWithoutDependencies }).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
         should = Types().That().Are(helper.ChildClass).Should();
@@ -1686,8 +1745,8 @@ public async Task NotDependOnAnyTest()
         should.NotDependOnAny(helper.BaseClass).AssertOnlyViolations(helper);
         should.NotDependOnAny(helper.BaseClassSystemType).AssertOnlyViolations(helper);
         should.NotDependOnAny(Classes().That().Are(helper.BaseClass)).AssertOnlyViolations(helper);
-        should.NotDependOnAny([helper.BaseClass]).AssertOnlyViolations(helper);
-        should.NotDependOnAny([helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.NotDependOnAny(new List<IType> { helper.BaseClass }).AssertOnlyViolations(helper);
+        should.NotDependOnAny(new List<System.Type> { helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotDependOnAny(helper.BaseClass)).AssertOnlyViolations(helper);
@@ -1698,8 +1757,8 @@ public async Task NotDependOnAnyTest()
         should.BeTypesThat().DoNotDependOnAny(helper.BaseClass).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(helper.BaseClassSystemType).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(Classes().That().Are(helper.BaseClass)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.BaseClass]).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<IType> { helper.BaseClass }).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<System.Type> { helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ChildClass).Should();
@@ -1708,23 +1767,26 @@ public async Task NotDependOnAnyTest()
         should.NotDependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DoNotDependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes))).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes))).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DoNotDependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ChildClass).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.NotDependOnAny().AssertNoViolations(helper);
         should.NotDependOnAny(new List<IType>()).AssertNoViolations(helper);
         should.NotDependOnAny(new List<System.Type>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().DoNotDependOnAny()).AssertNoViolations(helper);
         should.Be(Types().That().DoNotDependOnAny(new List<IType>())).AssertNoViolations(helper);
         should.Be(Types().That().DoNotDependOnAny(new List<System.Type>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().DoNotDependOnAny().AssertNoViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(new List<IType>()).AssertNoViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(new List<System.Type>()).AssertNoViolations(helper);
 
@@ -1733,44 +1795,44 @@ public async Task NotDependOnAnyTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotDependOnAny(helper.ClassWithoutDependencies, helper.BaseClass).AssertOnlyViolations(helper);
-        should.NotDependOnAny([helper.ClassWithoutDependencies, helper.BaseClass]).AssertOnlyViolations(helper);
+        should.NotDependOnAny(new List<IType> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertOnlyViolations(helper);
         should.NotDependOnAny(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertOnlyViolations(helper);
-        should.NotDependOnAny([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.NotDependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotDependOnAny(helper.ClassWithoutDependencies, helper.BaseClass)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotDependOnAny([helper.ClassWithoutDependencies, helper.BaseClass])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(new List<IType> { helper.ClassWithoutDependencies, helper.BaseClass })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotDependOnAny(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotDependOnAny([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotDependOnAny(helper.ClassWithoutDependencies, helper.BaseClass).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.ClassWithoutDependencies, helper.BaseClass]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<IType> { helper.ClassWithoutDependencies, helper.BaseClass }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<System.Type> { helper.ClassWithoutDependenciesSystemType, helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Input with multiple dependencies");
         should = Types().That().Are(helper.ClassWithMultipleDependencies).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotDependOnAny(helper.BaseClassWithMember, helper.OtherBaseClass).AssertOnlyViolations(helper);
-        should.NotDependOnAny([helper.BaseClassWithMember, helper.OtherBaseClass]).AssertOnlyViolations(helper);
+        should.NotDependOnAny(new List<IType> { helper.BaseClassWithMember, helper.OtherBaseClass }).AssertOnlyViolations(helper);
         should.NotDependOnAny(helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType).AssertOnlyViolations(helper);
-        should.NotDependOnAny([helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType]).AssertOnlyViolations(helper);
+        should.NotDependOnAny(new List<System.Type> { helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType }).AssertOnlyViolations(helper);
         should.NotDependOnAny(Classes().That().Are(helper.BaseClassWithMember, helper.OtherBaseClass)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotDependOnAny(helper.BaseClassWithMember, helper.OtherBaseClass)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotDependOnAny([helper.BaseClassWithMember, helper.OtherBaseClass])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(new List<IType> { helper.BaseClassWithMember, helper.OtherBaseClass })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotDependOnAny(helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotDependOnAny([helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotDependOnAny(new List<System.Type> { helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType })).AssertOnlyViolations(helper);
         should.Be(Classes().That().DoNotDependOnAny(helper.BaseClassWithMember, helper.OtherBaseClass)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotDependOnAny(helper.BaseClassWithMember, helper.OtherBaseClass).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.BaseClassWithMember, helper.OtherBaseClass]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<IType> { helper.BaseClassWithMember, helper.OtherBaseClass }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotDependOnAny([helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotDependOnAny(new List<System.Type> { helper.BaseClassWithMemberSystemType, helper.OtherBaseClassSystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotDependOnAny(Classes().That().Are(helper.BaseClassWithMember, helper.OtherBaseClass)).AssertOnlyViolations(helper);
 
         await helper.AssertSnapshotMatches();
@@ -1800,23 +1862,23 @@ public async Task NotHaveAnyAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributes(helper.UnusedAttribute).AssertNoViolations(helper);
-        should.NotHaveAnyAttributes([helper.UnusedAttribute]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributes(new List<Attribute> { helper.UnusedAttribute }).AssertNoViolations(helper);
         should.NotHaveAnyAttributes(helper.UnusedAttributeSystemType).AssertNoViolations(helper);
-        should.NotHaveAnyAttributes([helper.UnusedAttributeSystemType]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributes(new List<System.Type> { helper.UnusedAttributeSystemType }).AssertNoViolations(helper);
         should.NotHaveAnyAttributes(Attributes().That().Are(helper.UnusedAttribute)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributes(helper.UnusedAttribute)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributes([helper.UnusedAttribute])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(new List<Attribute> { helper.UnusedAttribute })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(helper.UnusedAttributeSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributes([helper.UnusedAttributeSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(new List<System.Type> { helper.UnusedAttributeSystemType })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(Attributes().That().Are(helper.UnusedAttribute))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributes(helper.UnusedAttribute).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributes([helper.UnusedAttribute]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(new List<Attribute> { helper.UnusedAttribute }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(helper.UnusedAttributeSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributes([helper.UnusedAttributeSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(new List<System.Type> { helper.UnusedAttributeSystemType }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(Attributes().That().Are(helper.UnusedAttribute)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
@@ -1824,23 +1886,23 @@ public async Task NotHaveAnyAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributes(helper.Attribute1).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributes([helper.Attribute1]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributes(new List<Attribute> { helper.Attribute1 }).AssertOnlyViolations(helper);
         should.NotHaveAnyAttributes(helper.Attribute1SystemType).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributes([helper.Attribute1SystemType]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType }).AssertOnlyViolations(helper);
         should.NotHaveAnyAttributes(Attributes().That().Are(helper.Attribute1)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributes(helper.Attribute1)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributes([helper.Attribute1])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(new List<Attribute> { helper.Attribute1 })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(helper.Attribute1SystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributes([helper.Attribute1SystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(Attributes().That().Are(helper.Attribute1))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributes(helper.Attribute1).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributes([helper.Attribute1]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(new List<Attribute> { helper.Attribute1 }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(helper.Attribute1SystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributes([helper.Attribute1SystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(Attributes().That().Are(helper.Attribute1)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
@@ -1850,25 +1912,28 @@ public async Task NotHaveAnyAttributesTest()
         should.NotHaveAnyAttributes(typeof(TypeDependencyNamespace.BaseClass)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DoNotHaveAnyAttributes(typeof(TypeDependencyNamespace.BaseClass))).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(typeof(TypeDependencyNamespace.BaseClass))).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DoNotHaveAnyAttributes(typeof(TypeDependencyNamespace.BaseClass)).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(typeof(TypeDependencyNamespace.BaseClass)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithoutAttributes).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.NotHaveAnyAttributes().AssertNoViolations(helper);
         should.NotHaveAnyAttributes(new List<Attribute>()).AssertNoViolations(helper);
         should.NotHaveAnyAttributes(new List<System.Type>()).AssertNoViolations(helper);
         should.NotHaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().DoNotHaveAnyAttributes()).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(new List<Attribute>())).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(new List<System.Type>())).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().DoNotHaveAnyAttributes().AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(new List<Attribute>()).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(new List<System.Type>()).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertNoViolations(helper);
@@ -1878,23 +1943,23 @@ public async Task NotHaveAnyAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributes(helper.Attribute1, helper.Attribute2).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributes([helper.Attribute1, helper.Attribute2]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributes(new List<Attribute> { helper.Attribute1, helper.Attribute2 }).AssertOnlyViolations(helper);
         should.NotHaveAnyAttributes(helper.Attribute1SystemType, helper.Attribute2SystemType).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributes([helper.Attribute1SystemType, helper.Attribute2SystemType]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.Attribute2SystemType }).AssertOnlyViolations(helper);
         should.NotHaveAnyAttributes(Attributes().That().Are(helper.Attribute1, helper.Attribute2)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributes(helper.Attribute1, helper.Attribute2)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributes([helper.Attribute1, helper.Attribute2])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(new List<Attribute> { helper.Attribute1, helper.Attribute2 })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(helper.Attribute1SystemType, helper.Attribute2SystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributes([helper.Attribute1SystemType, helper.Attribute2SystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.Attribute2SystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributes(Attributes().That().Are(helper.Attribute1, helper.Attribute2))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributes(helper.Attribute1, helper.Attribute2).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributes([helper.Attribute1, helper.Attribute2]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(new List<Attribute> { helper.Attribute1, helper.Attribute2 }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(helper.Attribute1SystemType, helper.Attribute2SystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributes([helper.Attribute1SystemType, helper.Attribute2SystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.Attribute2SystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributes(Attributes().That().Are(helper.Attribute1, helper.Attribute2)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
@@ -1939,60 +2004,60 @@ public async Task NotHaveAnyAttributesWithArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithArguments(helper.UnusedTypeArgumentSystemType).AssertNoViolations(helper);
-        should.NotHaveAnyAttributesWithArguments([helper.UnusedTypeArgumentSystemType]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(helper.UnusedTypeArgumentSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([helper.UnusedTypeArgumentSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgumentSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(helper.UnusedTypeArgumentSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([helper.UnusedTypeArgumentSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithArguments(helper.UnusedAttributeStringValue).AssertNoViolations(helper);
-        should.NotHaveAnyAttributesWithArguments([helper.UnusedAttributeStringValue]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedAttributeStringValue }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(helper.UnusedAttributeStringValue)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([helper.UnusedAttributeStringValue])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedAttributeStringValue })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(helper.UnusedAttributeStringValue).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([helper.UnusedAttributeStringValue]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedAttributeStringValue }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithArguments(helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithArguments([helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([helper.Attribute1TypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type without attributes");
         should = Types().That().Are(helper.ClassWithoutAttributes).Should();
@@ -2022,27 +2087,27 @@ public async Task NotHaveAnyAttributesWithArgumentsTest()
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.NotHaveAnyAttributesWithArguments([]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object>()).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.NotHaveAnyAttributesWithArguments([helper.UnusedTypeArgument, helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgument, helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
         should.NotHaveAnyAttributesWithArguments(helper.UnusedTypeArgument, helper.Attribute1StringArgument).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([helper.UnusedTypeArgument, helper.Attribute1StringArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgument, helper.Attribute1StringArgument })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(helper.UnusedTypeArgument, helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([helper.UnusedTypeArgument, helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.UnusedTypeArgument, helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(helper.UnusedTypeArgument, helper.Attribute1StringArgument).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
@@ -2050,15 +2115,15 @@ public async Task NotHaveAnyAttributesWithArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithArguments(helper.Attribute1StringArgument).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithArguments([helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments([helper.Attribute1StringArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1StringArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(helper.Attribute1StringArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments([helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithArguments(new List<object> { helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -2073,110 +2138,110 @@ public async Task NotHaveAnyAttributesWithNamedArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
         should.NotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertNoViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1TypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.UnusedTypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.UnusedTypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1TypeArgumentSystemType) }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.UnusedTypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.UnusedTypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.UnusedTypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
         should.NotHaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.UnusedAttributeStringValue)).AssertNoViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.UnusedAttributeStringValue)]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1StringArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.UnusedAttributeStringValue))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.UnusedAttributeStringValue)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("InvalidName", helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("InvalidName", helper.Attribute1StringArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("InvalidName", helper.Attribute1StringArgument) }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.UnusedAttributeStringValue)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.UnusedAttributeStringValue)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.UnusedAttributeStringValue) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.NotHaveAnyAttributesWithNamedArguments([]).AssertNoViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)>())).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)>()).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument), ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments, helper.ClassWithTwoAttributesWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.NotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.NotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments([("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAnyAttributesWithNamedArguments(new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -2191,105 +2256,105 @@ public async Task NotHaveAttributeWithArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute2TypeArgumentSystemType).AssertNoViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2TypeArgumentSystemType }).AssertNoViolations(helper);
         should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2TypeArgumentSystemType).AssertNoViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2TypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute2TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2TypeArgumentSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2TypeArgumentSystemType })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2TypeArgumentSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2TypeArgumentSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute2TypeArgumentSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2TypeArgumentSystemType }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2TypeArgumentSystemType).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2TypeArgumentSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2TypeArgumentSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute2StringArgument).AssertNoViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2StringArgument]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2StringArgument }).AssertNoViolations(helper);
         should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2StringArgument).AssertNoViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2StringArgument]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2StringArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute2StringArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2StringArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2StringArgument })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2StringArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2StringArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2StringArgument })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute2StringArgument).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute2StringArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute2StringArgument }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute2StringArgument).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute2StringArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute2StringArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1IntegerArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1IntegerArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1IntegerArgument })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1IntegerArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1IntegerArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1IntegerArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Unused attribute");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.UnusedAttribute, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.UnusedAttribute, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.UnusedAttribute, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
         should.NotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.UnusedAttribute, helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.UnusedAttribute, [helper.Attribute1StringArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.UnusedAttribute, new List<object> { helper.Attribute1StringArgument })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, helper.Attribute1StringArgument)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, [helper.Attribute1StringArgument])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, new List<object> { helper.Attribute1StringArgument })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.UnusedAttribute, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.UnusedAttribute, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.UnusedAttribute, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, helper.Attribute1StringArgument).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, [helper.Attribute1StringArgument]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.UnusedAttributeSystemType, new List<object> { helper.Attribute1StringArgument }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
@@ -2320,50 +2385,50 @@ public async Task NotHaveAttributeWithArgumentsTest()
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
-        should.NotHaveAttributeWithArguments(helper.Attribute1, []).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, []).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object>()).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object>()).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1TypeArgumentSystemType, helper.Attribute1IntegerArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithArguments, helper.ClassWithTwoAttributesWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, helper.Attribute1StringArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, [helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1, new List<object> { helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, helper.Attribute1StringArgument).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, [helper.Attribute1StringArgument]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithArguments(helper.Attribute1SystemType, new List<object> { helper.Attribute1StringArgument }).AssertOnlyViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -2378,105 +2443,105 @@ public async Task NotHaveAttributeWithNamedArgumentsTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute2TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute2TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute2TypeArgumentSystemType) }).AssertNoViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute2TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute2TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute2TypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute2TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute2TypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute2TypeArgumentSystemType) })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute2TypeArgumentSystemType))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute2TypeArgumentSystemType)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute2TypeArgumentSystemType) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute2TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute2TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute2TypeArgumentSystemType) }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute2TypeArgumentSystemType)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute2TypeArgumentSystemType)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute2TypeArgumentSystemType) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("No violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute2StringArgument)).AssertNoViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute2StringArgument)]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute2StringArgument) }).AssertNoViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute2StringArgument)).AssertNoViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute2StringArgument)]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute2StringArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute2StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute2StringArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute2StringArgument) })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute2StringArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute2StringArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute2StringArgument) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute2StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute2StringArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute2StringArgument) }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute2StringArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute2StringArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute2StringArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations with type arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Violations with value arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Unused attribute");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.UnusedAttribute, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertNoViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.UnusedAttribute, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.UnusedAttribute, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertNoViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertNoViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertNoViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttribute, ("NamedParameter1", helper.Attribute1TypeArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttribute, [("NamedParameter1", helper.Attribute1TypeArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttribute, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) })).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, ("NamedParameter1", helper.Attribute1TypeArgument))).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, [("NamedParameter1", helper.Attribute1TypeArgument)])).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttribute, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttribute, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttribute, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, ("NamedParameter1", helper.Attribute1TypeArgument)).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, [("NamedParameter1", helper.Attribute1TypeArgument)]).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.UnusedAttributeSystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgument) }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
@@ -2494,58 +2559,58 @@ public async Task NotHaveAttributeWithNamedArgumentsTest()
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, []).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, []).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)>()).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)>()).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [])).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)>())).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)>())).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, []).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, []).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)>()).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)>()).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple arguments");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument),]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType), ("NamedParameter2", helper.Attribute1StringArgument) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
         should = Types().That().Are(helper.ClassWithSingleAttributeWithNamedArguments, helper.ClassWithTwoAttributesWithNamedArguments).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.NotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType))).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)])).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, ("NamedParameter1", helper.Attribute1TypeArgumentSystemType)).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, [("NamedParameter1", helper.Attribute1TypeArgumentSystemType)]).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAttributeWithNamedArguments(helper.Attribute1SystemType, new List<(string, object)> { ("NamedParameter1", helper.Attribute1TypeArgumentSystemType) }).AssertOnlyViolations(helper);
 
         await helper.AssertSnapshotMatches();
     }
@@ -2561,66 +2626,108 @@ public async Task NotHaveNameTest()
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveName(helper.BaseClass.FullName).AssertNoViolations(helper);
         should.NotHaveNameMatching("^.*\\.Base.*$").AssertNoViolations(helper);
+        should.NotHaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
+        should.NotHaveNameEndingWith("Test").AssertNoViolations(helper);
+        should.NotHaveNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
         should.NotHaveFullName(helper.BaseClass.Name).AssertNoViolations(helper);
         should.NotHaveFullNameMatching("^Base.*$").AssertNoViolations(helper);
-        should.NotHaveNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
+        should.NotHaveFullNameStartingWith(helper.BaseClass.Name).AssertNoViolations(helper);
+        should.NotHaveFullNameEndingWith("Test").AssertNoViolations(helper);
         should.NotHaveFullNameContaining(helper.NonExistentObjectName).AssertNoViolations(helper);
-        should.NotHaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
-        should.NotHaveNameEndingWith("Test").AssertNoViolations(helper);
+        should.NotHaveAssemblyQualifiedName(helper.ChildClass.AssemblyQualifiedName).AssertNoViolations(helper);
+        should.NotHaveAssemblyQualifiedNameMatching("^.*\\.Child.*$").AssertNoViolations(helper);
+        should.NotHaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Name).AssertNoViolations(helper);
+        should.NotHaveAssemblyQualifiedNameEndingWith("Test").AssertNoViolations(helper);
+        should.NotHaveAssemblyQualifiedNameContaining(helper.NonExistentObjectName).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveName(helper.BaseClass.FullName)).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveNameMatching("^.*\\.Base.*$")).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveNameStartingWith(helper.BaseClass.Namespace.Name)).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveNameEndingWith("Test")).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveNameContaining(helper.BaseClass.Namespace.Name)).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveFullName(helper.BaseClass.Name)).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveFullNameMatching("^Base.*$")).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveNameContaining(helper.BaseClass.Namespace.Name)).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveFullNameStartingWith(helper.BaseClass.Name)).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveFullNameEndingWith("Test")).AssertNoViolations(helper);
         should.Be(Types().That().DoNotHaveFullNameContaining(helper.NonExistentObjectName)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveNameStartingWith(helper.BaseClass.Namespace.Name)).AssertNoViolations(helper);
-        should.Be(Types().That().DoNotHaveNameEndingWith("Test")).AssertNoViolations(helper);
-
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedName(helper.ChildClass.AssemblyQualifiedName)).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameMatching("^.*\\.Child.*$")).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Name)).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameEndingWith("Test")).AssertNoViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameContaining(helper.NonExistentObjectName)).AssertNoViolations(helper);
+        
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveName(helper.BaseClass.FullName).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveNameMatching("^.*\\.Base.*$").AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveNameEndingWith("Test").AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveFullName(helper.BaseClass.Name).AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveFullNameMatching("^Base.*$").AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveNameContaining(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveFullNameStartingWith(helper.BaseClass.Name).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveFullNameEndingWith("Test").AssertNoViolations(helper);
         should.BeTypesThat().DoNotHaveFullNameContaining(helper.NonExistentObjectName).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveNameStartingWith(helper.BaseClass.Namespace.Name).AssertNoViolations(helper);
-        should.BeTypesThat().DoNotHaveNameEndingWith("Test").AssertNoViolations(helper);
-
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedName(helper.ChildClass.AssemblyQualifiedName).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameMatching("^.*\\.Child.*$").AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Name).AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameEndingWith("Test").AssertNoViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameContaining(helper.NonExistentObjectName).AssertNoViolations(helper);
+        
         helper.AddSnapshotHeader("Violations");
         should = Types().That().Are(helper.BaseClass).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
         should.NotHaveName(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.NotHaveNameMatching("^Base.*$").AssertOnlyViolations(helper);
+        should.NotHaveNameStartingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.NotHaveNameEndingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.NotHaveNameContaining(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.NotHaveFullName(helper.BaseClass.FullName).AssertOnlyViolations(helper);
         should.NotHaveFullNameMatching("^.*\\.Base.*$").AssertOnlyViolations(helper);
-        should.NotHaveNameContaining(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.NotHaveFullNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.NotHaveFullNameEndingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.NotHaveFullNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
-        should.NotHaveNameStartingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
-        should.NotHaveNameEndingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.NotHaveAssemblyQualifiedName(helper.BaseClass.AssemblyQualifiedName).AssertOnlyViolations(helper);
+        should.NotHaveAssemblyQualifiedNameMatching("^.*\\.Base.*$").AssertOnlyViolations(helper);
+        should.NotHaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.NotHaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Assembly.FullName).AssertOnlyViolations(helper);
+        should.NotHaveAssemblyQualifiedNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().DoNotHaveName(helper.BaseClass.Name)).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveNameMatching("^Base.*$")).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveNameStartingWith(helper.BaseClass.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveNameEndingWith(helper.BaseClass.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveNameContaining(helper.BaseClass.Name)).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveFullName(helper.BaseClass.FullName)).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveFullNameMatching("^.*\\.Base.*$")).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveNameContaining(helper.BaseClass.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveFullNameStartingWith(helper.BaseClass.Namespace.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveFullNameEndingWith(helper.BaseClass.Name)).AssertOnlyViolations(helper);
         should.Be(Types().That().DoNotHaveFullNameContaining(helper.BaseClass.Namespace.Name)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveNameStartingWith(helper.BaseClass.Name)).AssertOnlyViolations(helper);
-        should.Be(Types().That().DoNotHaveNameEndingWith(helper.BaseClass.Name)).AssertOnlyViolations(helper);
-
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedName(helper.BaseClass.AssemblyQualifiedName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameMatching("^.*\\.Base.*$")).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Namespace.Name)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Assembly.FullName)).AssertOnlyViolations(helper);
+        should.Be(Types().That().DoNotHaveAssemblyQualifiedNameContaining(helper.BaseClass.Namespace.Name)).AssertOnlyViolations(helper);
+        
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().DoNotHaveName(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveNameMatching("^Base.*$").AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveNameStartingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveNameEndingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveNameContaining(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveFullName(helper.BaseClass.FullName).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveFullNameMatching("^.*\\.Base.*$").AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveNameContaining(helper.BaseClass.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveFullNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveFullNameEndingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
         should.BeTypesThat().DoNotHaveFullNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveNameStartingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
-        should.BeTypesThat().DoNotHaveNameEndingWith(helper.BaseClass.Name).AssertOnlyViolations(helper);
-
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedName(helper.BaseClass.AssemblyQualifiedName).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameMatching("^.*\\.Base.*$").AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameStartingWith(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameEndingWith(helper.BaseClass.Assembly.FullName).AssertOnlyViolations(helper);
+        should.BeTypesThat().DoNotHaveAssemblyQualifiedNameContaining(helper.BaseClass.Namespace.Name).AssertOnlyViolations(helper);
+        
         await helper.AssertSnapshotMatches();
     }
 
@@ -2636,22 +2743,22 @@ public async Task OnlyDependOnTest()
         should.OnlyDependOn(helper.BaseClass).AssertNoViolations(helper);
         should.OnlyDependOn(helper.BaseClassSystemType).AssertNoViolations(helper);
         should.OnlyDependOn(Classes().That().Are(helper.BaseClass)).AssertNoViolations(helper);
-        should.OnlyDependOn([helper.BaseClass]).AssertNoViolations(helper);
-        should.OnlyDependOn([helper.BaseClassSystemType]).AssertNoViolations(helper);
+        should.OnlyDependOn(new List<IType> { helper.BaseClass }).AssertNoViolations(helper);
+        should.OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().OnlyDependOn(helper.BaseClass)).AssertNoViolations(helper);
         should.Be(Types().That().OnlyDependOn(helper.BaseClassSystemType)).AssertNoViolations(helper);
         should.Be(Types().That().OnlyDependOn(Classes().That().Are(helper.BaseClass))).AssertNoViolations(helper);
-        should.Be(Types().That().OnlyDependOn([helper.BaseClass])).AssertNoViolations(helper);
-        should.Be(Types().That().OnlyDependOn([helper.BaseClassSystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().OnlyDependOn(new List<IType> { helper.BaseClass })).AssertNoViolations(helper);
+        should.Be(Types().That().OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType })).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().OnlyDependOn(helper.BaseClass).AssertNoViolations(helper);
         should.BeTypesThat().OnlyDependOn(helper.BaseClassSystemType).AssertNoViolations(helper);
         should.BeTypesThat().OnlyDependOn(Classes().That().Are(helper.BaseClass)).AssertNoViolations(helper);
-        should.BeTypesThat().OnlyDependOn([helper.BaseClass]).AssertNoViolations(helper);
-        should.BeTypesThat().OnlyDependOn([helper.BaseClassSystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().OnlyDependOn(new List<IType> { helper.BaseClass }).AssertNoViolations(helper);
+        should.BeTypesThat().OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType }).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
         should = Types().That().Are(helper.ClassWithMultipleDependencies).Should();
@@ -2660,15 +2767,15 @@ public async Task OnlyDependOnTest()
         should.OnlyDependOn(helper.BaseClass).AssertOnlyViolations(helper);
         should.OnlyDependOn(helper.BaseClassSystemType).AssertOnlyViolations(helper);
         should.OnlyDependOn(Classes().That().Are(helper.BaseClass)).AssertOnlyViolations(helper);
-        should.OnlyDependOn([helper.BaseClass]).AssertOnlyViolations(helper);
-        should.OnlyDependOn([helper.BaseClassSystemType]).AssertOnlyViolations(helper);
+        should.OnlyDependOn(new List<IType> { helper.BaseClass }).AssertOnlyViolations(helper);
+        should.OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType }).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().OnlyDependOn(helper.BaseClass)).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(helper.BaseClassSystemType)).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(Classes().That().Are(helper.BaseClass))).AssertOnlyViolations(helper);
-        should.Be(Types().That().OnlyDependOn([helper.BaseClass])).AssertOnlyViolations(helper);
-        should.Be(Types().That().OnlyDependOn([helper.BaseClassSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyDependOn(new List<IType> { helper.BaseClass })).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType })).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Type outside of architecture");
         should = Types().That().Are(helper.ClassWithMultipleDependencies).Should();
@@ -2677,25 +2784,28 @@ public async Task OnlyDependOnTest()
         should.OnlyDependOn(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().OnlyDependOn(typeof(AttributeNamespace.ClassWithoutAttributes))).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyDependOn(typeof(AttributeNamespace.ClassWithoutAttributes))).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().OnlyDependOn(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertOnlyViolations(helper);
+        should.BeTypesThat().OnlyDependOn(typeof(AttributeNamespace.ClassWithoutAttributes)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithMultipleDependencies).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.OnlyDependOn().AssertOnlyViolations(helper);
         should.OnlyDependOn(new List<IType>()).AssertOnlyViolations(helper);
         should.OnlyDependOn(new List<System.Type>()).AssertOnlyViolations(helper);
         should.OnlyDependOn(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().OnlyDependOn()).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(new List<IType>())).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(new List<System.Type>())).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(Classes().That().HaveFullName(helper.NonExistentObjectName))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().OnlyDependOn().AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyDependOn(new List<IType>()).AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyDependOn(new List<System.Type>()).AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyDependOn(Classes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
@@ -2705,23 +2815,23 @@ public async Task OnlyDependOnTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.OnlyDependOn(helper.BaseClass, helper.OtherBaseClass).AssertOnlyViolations(helper);
-        should.OnlyDependOn([helper.BaseClass, helper.OtherBaseClass]).AssertOnlyViolations(helper);
+        should.OnlyDependOn(new List<IType> { helper.BaseClass, helper.OtherBaseClass }).AssertOnlyViolations(helper);
         should.OnlyDependOn(helper.BaseClassSystemType, helper.OtherBaseClassSystemType).AssertOnlyViolations(helper);
-        should.OnlyDependOn([helper.BaseClassSystemType, helper.OtherBaseClassSystemType]).AssertOnlyViolations(helper);
+        should.OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType, helper.OtherBaseClassSystemType }).AssertOnlyViolations(helper);
         should.OnlyDependOn(Classes().That().Are(helper.BaseClass, helper.OtherBaseClass)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().OnlyDependOn(helper.BaseClass, helper.OtherBaseClass)).AssertOnlyViolations(helper);
-        should.Be(Types().That().OnlyDependOn([helper.BaseClass, helper.OtherBaseClass])).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyDependOn(new List<IType> { helper.BaseClass, helper.OtherBaseClass })).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(helper.BaseClassSystemType, helper.OtherBaseClassSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().OnlyDependOn([helper.BaseClassSystemType, helper.OtherBaseClassSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType, helper.OtherBaseClassSystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyDependOn(Classes().That().Are(helper.BaseClass, helper.OtherBaseClass))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().OnlyDependOn(helper.BaseClass, helper.OtherBaseClass).AssertOnlyViolations(helper);
-        should.BeTypesThat().OnlyDependOn([helper.BaseClass, helper.OtherBaseClass]).AssertOnlyViolations(helper);
+        should.BeTypesThat().OnlyDependOn(new List<IType> { helper.BaseClass, helper.OtherBaseClass }).AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyDependOn(helper.BaseClassSystemType, helper.OtherBaseClassSystemType).AssertOnlyViolations(helper);
-        should.BeTypesThat().OnlyDependOn([helper.BaseClassSystemType, helper.OtherBaseClassSystemType]).AssertOnlyViolations(helper);
+        should.BeTypesThat().OnlyDependOn(new List<System.Type> { helper.BaseClassSystemType, helper.OtherBaseClassSystemType }).AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyDependOn(Classes().That().Are(helper.BaseClass, helper.OtherBaseClass)).AssertOnlyViolations(helper);
 
         await helper.AssertSnapshotMatches();
@@ -2751,23 +2861,23 @@ public async Task OnlyHaveAttributesTest()
         
         helper.AddSnapshotSubHeader("Conditions");
         should.OnlyHaveAttributes(helper.Attribute1).AssertNoViolations(helper);
-        should.OnlyHaveAttributes([helper.Attribute1]).AssertNoViolations(helper);
+        should.OnlyHaveAttributes(new List<Attribute> { helper.Attribute1 }).AssertNoViolations(helper);
         should.OnlyHaveAttributes(helper.Attribute1SystemType).AssertNoViolations(helper);
-        should.OnlyHaveAttributes([helper.Attribute1SystemType]).AssertNoViolations(helper);
+        should.OnlyHaveAttributes(new List<System.Type> { helper.Attribute1SystemType }).AssertNoViolations(helper);
         should.OnlyHaveAttributes(Attributes().That().Are(helper.Attribute1)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().OnlyHaveAttributes(helper.Attribute1)).AssertNoViolations(helper);
-        should.Be(Types().That().OnlyHaveAttributes([helper.Attribute1])).AssertNoViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(new List<Attribute> { helper.Attribute1 })).AssertNoViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(helper.Attribute1SystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().OnlyHaveAttributes([helper.Attribute1SystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(new List<System.Type> { helper.Attribute1SystemType })).AssertNoViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(Attributes().That().Are(helper.Attribute1))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().OnlyHaveAttributes(helper.Attribute1).AssertNoViolations(helper);
-        should.BeTypesThat().OnlyHaveAttributes([helper.Attribute1]).AssertNoViolations(helper);
+        should.BeTypesThat().OnlyHaveAttributes(new List<Attribute> { helper.Attribute1 }).AssertNoViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(helper.Attribute1SystemType).AssertNoViolations(helper);
-        should.BeTypesThat().OnlyHaveAttributes([helper.Attribute1SystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().OnlyHaveAttributes(new List<System.Type> { helper.Attribute1SystemType }).AssertNoViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(Attributes().That().Are(helper.Attribute1)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Violations");
@@ -2775,16 +2885,16 @@ public async Task OnlyHaveAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.OnlyHaveAttributes(helper.UnusedAttribute).AssertOnlyViolations(helper);
-        should.OnlyHaveAttributes([helper.UnusedAttribute]).AssertOnlyViolations(helper);
+        should.OnlyHaveAttributes(new List<Attribute> { helper.UnusedAttribute }).AssertOnlyViolations(helper);
         should.OnlyHaveAttributes(helper.UnusedAttributeSystemType).AssertOnlyViolations(helper);
-        should.OnlyHaveAttributes([helper.UnusedAttributeSystemType]).AssertOnlyViolations(helper);
+        should.OnlyHaveAttributes(new List<System.Type> { helper.UnusedAttributeSystemType }).AssertOnlyViolations(helper);
         should.OnlyHaveAttributes(Attributes().That().Are(helper.UnusedAttribute)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().OnlyHaveAttributes(helper.UnusedAttribute)).AssertOnlyViolations(helper);
-        should.Be(Types().That().OnlyHaveAttributes([helper.UnusedAttribute])).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(new List<Attribute> { helper.UnusedAttribute })).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(helper.UnusedAttributeSystemType)).AssertOnlyViolations(helper);
-        should.Be(Types().That().OnlyHaveAttributes([helper.UnusedAttributeSystemType])).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(new List<System.Type> { helper.UnusedAttributeSystemType })).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(Attributes().That().Are(helper.UnusedAttribute))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotHeader("Attribute outside of architecture");
@@ -2794,25 +2904,28 @@ public async Task OnlyHaveAttributesTest()
         should.OnlyHaveAttributes(typeof(TypeDependencyNamespace.BaseClass)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().OnlyHaveAttributes(typeof(TypeDependencyNamespace.BaseClass))).AssertOnlyViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(typeof(TypeDependencyNamespace.BaseClass))).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().OnlyHaveAttributes(typeof(TypeDependencyNamespace.BaseClass)).AssertOnlyViolations(helper);
+        should.BeTypesThat().OnlyHaveAttributes(typeof(TypeDependencyNamespace.BaseClass)).AssertException<TypeDoesNotExistInArchitecture>(helper);
 
         helper.AddSnapshotHeader("Empty arguments");
         should = Types().That().Are(helper.ClassWithSingleAttribute).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
+        should.OnlyHaveAttributes().AssertOnlyViolations(helper);
         should.OnlyHaveAttributes(new List<Attribute>()).AssertOnlyViolations(helper);
         should.OnlyHaveAttributes(new List<System.Type>()).AssertOnlyViolations(helper);
         should.OnlyHaveAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
+        should.Be(Types().That().OnlyHaveAttributes()).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(new List<Attribute>())).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(new List<System.Type>())).AssertOnlyViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName))).AssertOnlyViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
+        should.BeTypesThat().OnlyHaveAttributes().AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(new List<Attribute>()).AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(new List<System.Type>()).AssertOnlyViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
@@ -2822,23 +2935,23 @@ public async Task OnlyHaveAttributesTest()
 
         helper.AddSnapshotSubHeader("Conditions");
         should.OnlyHaveAttributes(helper.Attribute1, helper.Attribute2).AssertNoViolations(helper);
-        should.OnlyHaveAttributes([helper.Attribute1, helper.Attribute2]).AssertNoViolations(helper);
+        should.OnlyHaveAttributes(new List<Attribute> { helper.Attribute1, helper.Attribute2 }).AssertNoViolations(helper);
         should.OnlyHaveAttributes(helper.Attribute1SystemType, helper.Attribute2SystemType).AssertNoViolations(helper);
-        should.OnlyHaveAttributes([helper.Attribute1SystemType, helper.Attribute2SystemType]).AssertNoViolations(helper);
+        should.OnlyHaveAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.Attribute2SystemType }).AssertNoViolations(helper);
         should.OnlyHaveAttributes(Attributes().That().Are(helper.Attribute1, helper.Attribute2)).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
         should.Be(Types().That().OnlyHaveAttributes(helper.Attribute1, helper.Attribute2)).AssertNoViolations(helper);
-        should.Be(Types().That().OnlyHaveAttributes([helper.Attribute1, helper.Attribute2])).AssertNoViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(new List<Attribute> { helper.Attribute1, helper.Attribute2 })).AssertNoViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(helper.Attribute1SystemType, helper.Attribute2SystemType)).AssertNoViolations(helper);
-        should.Be(Types().That().OnlyHaveAttributes([helper.Attribute1SystemType, helper.Attribute2SystemType])).AssertNoViolations(helper);
+        should.Be(Types().That().OnlyHaveAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.Attribute2SystemType })).AssertNoViolations(helper);
         should.Be(Types().That().OnlyHaveAttributes(Attributes().That().Are(helper.Attribute1, helper.Attribute2))).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates as conditions");
         should.BeTypesThat().OnlyHaveAttributes(helper.Attribute1, helper.Attribute2).AssertNoViolations(helper);
-        should.BeTypesThat().OnlyHaveAttributes([helper.Attribute1, helper.Attribute2]).AssertNoViolations(helper);
+        should.BeTypesThat().OnlyHaveAttributes(new List<Attribute> { helper.Attribute1, helper.Attribute2 }).AssertNoViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(helper.Attribute1SystemType, helper.Attribute2SystemType).AssertNoViolations(helper);
-        should.BeTypesThat().OnlyHaveAttributes([helper.Attribute1SystemType, helper.Attribute2SystemType]).AssertNoViolations(helper);
+        should.BeTypesThat().OnlyHaveAttributes(new List<System.Type> { helper.Attribute1SystemType, helper.Attribute2SystemType }).AssertNoViolations(helper);
         should.BeTypesThat().OnlyHaveAttributes(Attributes().That().Are(helper.Attribute1, helper.Attribute2)).AssertNoViolations(helper);
 
         helper.AddSnapshotHeader("Multiple inputs");
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.BeTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.BeTest.verified.txt
index be5d74f70..0393ea11e 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.BeTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.BeTest.verified.txt
@@ -88,6 +88,15 @@ Message:
 
 
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not exist
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not exist" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should not exist
 Result: False
 Description: TypeDependencyNamespace.BaseClass is TypeDependencyNamespace.BaseClass
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.CallAnyTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.CallAnyTest.verified.txt
index 97fe9bf7b..e9709c523 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.CallAnyTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.CallAnyTest.verified.txt
@@ -2,13 +2,13 @@
 
 ----- Conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
@@ -64,30 +64,30 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does call
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does not call any methods
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does call
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does not call any methods
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does call
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does not call any methods
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does call
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does not call any methods
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does call
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does not call any methods
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" should call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does call
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies() does not call any methods
 
 
 
@@ -155,30 +155,48 @@ Message:
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any of no methods (impossible)
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any of no methods (impossible)" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+
+
+
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any of no methods (impossible)
+Result: False
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Message: 
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any of no methods (impossible)" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any Method members that have full name "NotTheNameOfAnyObject"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should call any Method members that have full name "NotTheNameOfAnyObject"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 
 
 
 ----- Predicates -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that call one of no methods (impossible)
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any method
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that call one of no methods (impossible)
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any method
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that call one of no methods (impossible)" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that call one of no methods (impossible)
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any method" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any method
+
+
+
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any method
+Result: False
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any method
+Message: 
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any method" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any method
 
 
 
@@ -193,11 +211,20 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that call one of no methods (impossible)
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any method
+Result: False
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does exist
+Message: 
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any method" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does exist
+
+
+
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any method
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does exist
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that call one of no methods (impossible)" failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any method" failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does exist
 
 
@@ -217,48 +244,48 @@ Message:
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodD...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodD..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 
 
 
 ----- Predicates -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDep...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho...
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDep...
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe..." failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho...
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDep...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho...
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDep...
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe..." failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Metho...
 
 
 
@@ -273,20 +300,20 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe...
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does exist
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend..." failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe..." failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does exist
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe...
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does exist
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDepend..." failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDe..." failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does exist
 
 
@@ -310,18 +337,18 @@ Description: System.Void MethodDependencyNamespace.MethodDependencyClass::Method
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() only calls "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()"
 
 
 
 ----- Predicates -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespac...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyName...
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() passed
 Message: 
@@ -338,7 +365,7 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespac...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyName...
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() passed
 Message: 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTest.verified.txt
index 84a0cd910..3a84ddbf6 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTest.verified.txt
@@ -2,13 +2,13 @@
 
 ----- Conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
@@ -20,13 +20,13 @@ Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should depend on "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
@@ -100,48 +100,48 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any Classes that are "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any Classes that are "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+"Types that have full name "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
@@ -243,30 +243,18 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "AttributeNamespace.ClassWithoutAttributes"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on "AttributeNamespace.ClassWithoutAttributes"
 Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ----- Predicates -----
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "AttributeNamespace.ClassWithoutAttributes"
-Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "AttributeNamespace.ClassWithoutAttributes"
-Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "AttributeNamespace.ClassWithoutAttributes"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "AttributeNamespace.ClassWithoutAttributes"
-
-
+Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ----- Predicates as conditions -----
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "AttributeNamespace.ClassWithoutAttributes"
-Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does exist
-Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "AttributeNamespace.ClassWithoutAttributes"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does exist
-
-
+Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ===== Empty arguments =====
 
@@ -274,48 +262,66 @@ Message:
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any of no types (impossible)
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any of no types (impossible)" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any of no types (impossible)
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any of no types (impossible)" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
+
+
+
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any of no types (impossible)
+Result: False
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any of no types (impossible)" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any Classes that have full name "NotTheNameOfAnyObject"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any Classes that have full name "NotTheNameOfAnyObject"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any of no types (impossible)
+Result: False
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any of no types (impossible)
+Message: 
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any of no types (impossible)" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any of no types (impossible)
+
+
+
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any of no types (impossible)
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any of no types (impossible)
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any of no types (impossible)" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any of no types (impossible)
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any of no types (impossible)
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any of no types (impossible)
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any of no types (impossible)" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any of no types (impossible)
 
 
 
@@ -330,20 +336,29 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any of no types (impossible)
+Result: False
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does exist
+Message: 
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any of no types (impossible)" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any of no types (impossible)
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies does exist
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any of no types (impossible)" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies does exist
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any of no types (impossible)
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies does exist
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any of no types (impossible)" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies does exist
 
 
@@ -363,112 +378,112 @@ Message:
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies only depends on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 
 
@@ -479,31 +494,31 @@ Message:
 
 Query: Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithoutDependencies does depend on System.Object
+Description: TypeDependencyNamespace.ClassWithoutDependencies does not depend on any type
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"" failed:
-	TypeDependencyNamespace.ClassWithoutDependencies does depend on System.Object
+	TypeDependencyNamespace.ClassWithoutDependencies does not depend on any type
 
 
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be Types that depend on "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be Types that depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithoutDependencies is not Types that depend on "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
+Description: TypeDependencyNamespace.ClassWithoutDependencies is not Types that depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be Types that depend on "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"" failed:
-	TypeDependencyNamespace.ClassWithoutDependencies is not Types that depend on "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
+"Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be Types that depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"" failed:
+	TypeDependencyNamespace.ClassWithoutDependencies is not Types that depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be types that depend on "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be types that depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithoutDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be types that depend on "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithoutDependencies" should be types that depend on any "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass"" failed:
 	TypeDependencyNamespace.ClassWithoutDependencies is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass"
 
 
@@ -512,7 +527,7 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" should depend on any "TypeDependencyNamespace.BaseClassWithMultipleDependencies"
+Query: Types that are "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" should depend on "TypeDependencyNamespace.BaseClassWithMultipleDependencies"
 Result: True
 Description: TypeDependencyNamespace.ChildClass1 passed
 Result: True
@@ -520,15 +535,15 @@ Description: TypeDependencyNamespace.ChildClass2 passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.BaseClass" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that are "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.BaseClass" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does depend on System.Object
+Description: TypeDependencyNamespace.BaseClass does not depend on any type
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass only depends on "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.BaseClass" should depend on any "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
-	TypeDependencyNamespace.BaseClass does depend on System.Object
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+"Types that are "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.BaseClass" should depend on "TypeDependencyNamespace.ClassWithoutDependencies"" failed:
+	TypeDependencyNamespace.BaseClass does not depend on any type
+	TypeDependencyNamespace.ChildClass only depends on "TypeDependencyNamespace.BaseClass"
 
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTypesThatTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTypesThatTest.verified.txt
index 6ca2df934..4744b0226 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTypesThatTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTypesThatTest.verified.txt
@@ -10,10 +10,10 @@ All Evaluations passed
 
 Query: Types that are "TypeDependencyNamespace.BaseClass" should depend on any types that are "TypeDependencyNamespace.ChildClass"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does depend on System.Object
+Description: TypeDependencyNamespace.BaseClass does not depend on any type
 Message: 
 "Types that are "TypeDependencyNamespace.BaseClass" should depend on any types that are "TypeDependencyNamespace.ChildClass"" failed:
-	TypeDependencyNamespace.BaseClass does depend on System.Object
+	TypeDependencyNamespace.BaseClass does not depend on any type
 
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt
index 5c044adfc..8c351ccda 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt
@@ -2,25 +2,25 @@
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -34,25 +34,25 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -66,25 +66,25 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -100,86 +100,86 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
 Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any Attributes that are "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any Attributes that are "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
 "Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any Attributes that are "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any Attributes that are "AttributeNamespace.UnusedAttribute"
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have "AttributeNamespace.UnusedAttribute"
 
 
 
@@ -194,38 +194,38 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does exist
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithTwoAttributes does exist
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does exist
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithTwoAttributes does exist
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does exist
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithTwoAttributes does exist
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does exist
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithTwoAttributes does exist
 
 
@@ -243,50 +243,59 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have one of no attributes (impossible)
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any of no attributes (impossible)
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any of no attributes (always true)
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have one of no attributes (impossible)" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any of no attributes (always true)
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any of no attributes (impossible)" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have one of no attributes (impossible)
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any of no attributes (impossible)
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any of no attributes (always true)
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have one of no attributes (impossible)" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any of no attributes (always true)
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any of no attributes (impossible)" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
 Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any Attributes that have full name "NotTheNameOfAnyObject"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any Attributes that have full name "NotTheNameOfAnyObject"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
 "Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any Attributes that have full name "NotTheNameOfAnyObject"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any Attributes that have full name "NotTheNameOfAnyObject"
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have one of no attributes (impossible)
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any of no attributes (always empty)
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have one of no attributes (impossible)
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have any of no attributes (always empty)
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have one of no attributes (impossible)" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that have one of no attributes (impossible)
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any of no attributes (always empty)" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have any of no attributes (always empty)
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have one of no attributes (impossible)
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any of no attributes (always empty)
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have one of no attributes (impossible)
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have any of no attributes (always empty)
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have one of no attributes (impossible)" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that have one of no attributes (impossible)
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any of no attributes (always empty)" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have any of no attributes (always empty)
+
+
+
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any of no attributes (always empty)
+Result: False
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that have any of no attributes (always empty)
+Message: 
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any of no attributes (always empty)" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that have any of no attributes (always empty)
 
 
 
@@ -301,20 +310,29 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have one of no attributes (impossible)
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any of no attributes (always empty)
+Result: False
+Description: AttributeNamespace.ClassWithTwoAttributes does exist
+Message: 
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any of no attributes (always empty)" failed:
+	AttributeNamespace.ClassWithTwoAttributes does exist
+
+
+
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any of no attributes (always empty)
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does exist
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have one of no attributes (impossible)" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any of no attributes (always empty)" failed:
 	AttributeNamespace.ClassWithTwoAttributes does exist
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have one of no attributes (impossible)
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any of no attributes (always empty)
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does exist
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have one of no attributes (impossible)" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any of no attributes (always empty)" failed:
 	AttributeNamespace.ClassWithTwoAttributes does exist
 
 
@@ -364,25 +382,25 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -396,25 +414,25 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that have any "AttributeNamespace.Attribute1" or "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -430,7 +448,7 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" should have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" should have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Result: True
@@ -438,20 +456,20 @@ Description: AttributeNamespace.ClassWithThreeAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should have "AttributeNamespace.Attribute1"
 Result: False
-Description: AttributeNamespace.ClassWithoutAttributes does not have any "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithoutAttributes does not have any attributes
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should have any "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithoutAttributes does not have any "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithoutAttributes does not have any attributes
 
 
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" should be Types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Result: True
@@ -459,20 +477,20 @@ Description: AttributeNamespace.ClassWithThreeAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be Types that have "AttributeNamespace.Attribute1"
 Result: False
-Description: AttributeNamespace.ClassWithoutAttributes is not Types that have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithoutAttributes is not Types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be Types that have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithoutAttributes is not Types that have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be Types that have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithoutAttributes is not Types that have "AttributeNamespace.Attribute1"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" should be types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" should be types that have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Result: True
@@ -480,13 +498,13 @@ Description: AttributeNamespace.ClassWithThreeAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be types that have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be types that have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithoutAttributes is not "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" or "AttributeNamespace.ClassWithSingleAttributeWithArguments" or "AttributeNamespace.ClassWithTwoAttributesWithArguments" or "AttributeNamespace.ClassWithThreeAttributesWithArguments" or "AttributeNamespace.ClassWithSingleAttributeWithNamedArguments" or "AttributeNamespace.ClassWithTwoAttributesWithNamedArguments" or "AttributeNamespace.ClassWithThreeAttributesWithNamedArguments"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be types that have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithoutAttributes" should be types that have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithoutAttributes is not "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" or "AttributeNamespace.ClassWithThreeAttributes" or "AttributeNamespace.ClassWithSingleAttributeWithArguments" or "AttributeNamespace.ClassWithTwoAttributesWithArguments" or "AttributeNamespace.ClassWithThreeAttributesWithArguments" or "AttributeNamespace.ClassWithSingleAttributeWithNamedArguments" or "AttributeNamespace.ClassWithTwoAttributesWithNamedArguments" or "AttributeNamespace.ClassWithThreeAttributesWithNamedArguments"
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesThatTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesThatTest.verified.txt
index 142f971c0..fbe9ca82e 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesThatTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesThatTest.verified.txt
@@ -10,10 +10,10 @@ All Evaluations passed
 
 Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have attributes that are "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 Message: 
 "Types that are "AttributeNamespace.ClassWithTwoAttributes" should have attributes that are "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithTwoAttributes does not have any "AttributeNamespace.UnusedAttribute"
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
 
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveNameTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveNameTest.verified.txt
index d31f14a59..263ac551f 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveNameTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveNameTest.verified.txt
@@ -14,6 +14,24 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have name starting with "Base"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have name ending with "Class"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have name containing "Base"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should have full name "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
@@ -26,7 +44,13 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should have name containing "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have full name starting with "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have full name ending with "BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -38,13 +62,31 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should have name starting with "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should have name ending with "Class"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name matching "^TypeDependencyNamespace.BaseClass, .*DependencyAssembly.*$"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name starting with "TypeDependencyNamespace.BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name containing "DependencyAssembly"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -64,6 +106,24 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name starting with "Base"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name ending with "Class"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name containing "Base"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
@@ -76,7 +136,13 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name containing "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name starting with "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name ending with "BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -88,13 +154,31 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name starting with "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken...
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name ending with "Class"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name matching "^TypeDependencyNamespace.BaseClass, .*DependencyAssembly.*$"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name starting with "TypeDependencyNamespace.BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name containing "DependencyAssembly"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -114,6 +198,24 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name starting with "Base"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name ending with "Class"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name containing "Base"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name "TypeDependencyNamespace.BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
@@ -126,7 +228,13 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name containing "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name starting with "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name ending with "BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -138,13 +246,31 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name starting with "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken...
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name ending with "Class"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name matching "^TypeDependencyNamespace.BaseClass, .*DependencyAssembly.*$"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name starting with "TypeDependencyNamespace.BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name containing "DependencyAssembly"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -172,6 +298,33 @@ Message:
 
 
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have name starting with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have name BaseClass
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have name ending with "Base"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have name ending with "Base"" failed:
+	TypeDependencyNamespace.BaseClass does have name BaseClass
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have name containing "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have name containing "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have name BaseClass
+
+
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should have full name "BaseClass"
 Result: False
 Description: TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
@@ -190,12 +343,21 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should have name containing "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have full name starting with "Base"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Description: TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should have name containing "TypeDependencyNamespace"" failed:
-	TypeDependencyNamespace.BaseClass does have name BaseClass
+"Types that are "TypeDependencyNamespace.BaseClass" should have full name starting with "Base"" failed:
+	TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have full name ending with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have full name ending with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
 
 
 
@@ -208,121 +370,322 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should have name starting with "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should have name starting with "TypeDependencyNamespace"" failed:
-	TypeDependencyNamespace.BaseClass does have name BaseClass
+"Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should have name ending with "Base"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should have name ending with "Base"" failed:
-	TypeDependencyNamespace.BaseClass does have name BaseClass
+"Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name starting with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name starting with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name ending with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name ending with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name containing "NotTheNameOfAnyObject"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should have assembly qualified name containing "NotTheNameOfAnyObject"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 
 
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name "BaseClass"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name "TypeDependencyNamespace.BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have name "TypeDependencyNamespace.BaseClass"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have name "TypeDependencyNamespace.BaseClass"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name matching "^Base.*$"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name "^.*\.Base.*$"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have name "^.*\.Base.*$"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name "^.*\.Base.*$"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have name "^.*\.Base.*$"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name "TypeDependencyNamespace.BaseClass"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name starting with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have name starting with "TypeDependencyNamespace"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have name starting with "TypeDependencyNamespace"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name matching "^.*\.Base.*$"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name ending with "Base"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have name ending with "Base"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name ending with "Base"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have name ending with "Base"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name containing "Base"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name containing "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have name containing "TypeDependencyNamespace"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name containing "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have name containing "TypeDependencyNamespace"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name containing "TypeDependencyNamespace"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have full name "BaseClass"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have full name "BaseClass"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name starting with "Base"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name "^Base.*$"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have full name "^Base.*$"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name "^Base.*$"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have full name "^Base.*$"
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have name ending with "Class"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name starting with "Base"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have full name starting with "Base"
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name starting with "Base"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have full name starting with "Base"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name ending with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have full name ending with "TypeDependencyNamespace"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name ending with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have full name ending with "TypeDependencyNamespace"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name containing "NotTheNameOfAnyObject"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have full name containing "NotTheNameOfAnyObject"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have full name containing "NotTheNameOfAnyObject"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have full name containing "NotTheNameOfAnyObject"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name "TypeDependencyNamespace.BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name "TypeDependencyNamespace.BaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name "TypeDependencyNamespace.BaseClass"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name starting with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name starting with "BaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name starting with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name starting with "BaseClass"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name ending with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name ending with "TypeDependencyNamespace"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name ending with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name ending with "TypeDependencyNamespace"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name containing "NotTheNameOfAnyObject"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name containing "NotTheNameOfAnyObject"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that have assembly qualified name containing "NotTheNameOfAnyObject"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that have assembly qualified name containing "NotTheNameOfAnyObject"
+
+
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name "BaseClass"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name "TypeDependencyNamespace.BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have name "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name matching "^Base.*$"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name "^.*\.Base.*$"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have name "^.*\.Base.*$"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name "TypeDependencyNamespace.BaseClass"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name starting with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name matching "^.*\.Base.*$"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name ending with "Base"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have name ending with "Base"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name containing "Base"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name containing "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have name containing "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name containing "TypeDependencyNamespace"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name starting with "Base"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name "^Base.*$"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name "^Base.*$"" failed:
+	TypeDependencyNamespace.BaseClass does exist
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have name ending with "Class"
-Result: True
-Description: TypeDependencyNamespace.BaseClass passed
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name starting with "Base"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
 Message: 
-All Evaluations passed
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name starting with "Base"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name ending with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name ending with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name containing "NotTheNameOfAnyObject"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have full name containing "NotTheNameOfAnyObject"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name "TypeDependencyNamespace.BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name "^TypeDependencyNamespace.BaseClass, .*NotTheNameOfAnyObject.*$"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name starting with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name starting with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name ending with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name ending with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name containing "NotTheNameOfAnyObject"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does exist
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that have assembly qualified name containing "NotTheNameOfAnyObject"" failed:
+	TypeDependencyNamespace.BaseClass does exist
+
+
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotBeTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotBeTest.verified.txt
index 3799c65a5..a117e7f41 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotBeTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotBeTest.verified.txt
@@ -60,7 +60,7 @@ Description: TypeDependencyNamespace.OtherChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be Types that are not "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be Types that are not Classes that are "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Result: True
@@ -303,7 +303,15 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that depend on "TypeDependencyNamespace.BaseClass" should exist
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should not be any of no objects (always true)
+Result: True
+Description: TypeDependencyNamespace.ChildClass passed
+Result: True
+Description: TypeDependencyNamespace.OtherChildClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should not be any of no objects (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Result: True
@@ -329,7 +337,15 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be Types that are not no object (always true)
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be Types that are not any of no objects (always true)
+Result: True
+Description: TypeDependencyNamespace.ChildClass passed
+Result: True
+Description: TypeDependencyNamespace.OtherChildClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be Types that are not any of no objects (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Result: True
@@ -355,7 +371,15 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be types that are not no object (always true)
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be types that are not any of no objects (always true)
+Result: True
+Description: TypeDependencyNamespace.ChildClass passed
+Result: True
+Description: TypeDependencyNamespace.OtherChildClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that depend on "TypeDependencyNamespace.BaseClass" should be types that are not any of no objects (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Result: True
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt
index 9dc359cf6..85664aa96 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt
@@ -2,13 +2,13 @@
 
 ----- Conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
@@ -34,7 +34,7 @@ Description: System.Void MethodDependencyNamespace.MethodDependencyClass::Method
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependenc...
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
@@ -54,7 +54,7 @@ Description: System.Void MethodDependencyNamespace.MethodDependencyClass::Method
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependenc...
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
@@ -64,30 +64,30 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 
 
 
@@ -111,12 +111,12 @@ Message:
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 
 
 
@@ -140,11 +140,11 @@ Message:
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"" failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 
 
@@ -161,7 +161,13 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call one of no methods (always true)
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any of no methods (always true)
+Result: True
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
+Message: 
+All Evaluations passed
+
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any of no methods (always true)
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
@@ -169,7 +175,13 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call one of no methods (always true)
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any of no methods (always true)
+Result: True
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
+Message: 
+All Evaluations passed
+
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be method members that do not call any of no methods (always true)
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Message: 
@@ -181,85 +193,85 @@ All Evaluations passed
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.M...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.M..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.M...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.M..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 
 
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Met...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Met..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 
 
 
 ----- Predicates -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Me...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespac...
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Me...
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M..." failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespac...
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Me...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespac...
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.Me...
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M..." failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespac...
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies(...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependenc...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Meth...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void ...
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies(..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Meth...
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependenc..." failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void ...
 
 
 
 ----- Predicates as conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M...
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho..." failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M..." failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M...
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void Metho..." failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void M..." failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 
 
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies(...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependenc...
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies(..." failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies()" should be method members that do not call any Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependenc..." failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 
 
@@ -268,7 +280,7 @@ Message:
 
 ----- Conditions -----
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should not call "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()"
 Result: True
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
 Result: True
@@ -278,13 +290,13 @@ All Evaluations passed
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependen...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 Message: 
 "Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependen..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1() and System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()"
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() does call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" and "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()"
 
 
 
@@ -298,15 +310,15 @@ Description: System.Void MethodDependencyNamespace.MethodDependencyClass::Method
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNa...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependen...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependenc...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDepen...
 Result: False
-Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependenc...
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDepen...
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNa..." failed:
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependenc...
-	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependenc...
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependen..." failed:
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDepen...
+	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not Method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDepen...
 
 
 
@@ -320,13 +332,13 @@ Description: System.Void MethodDependencyNamespace.MethodDependencyClass::Method
 Message: 
 All Evaluations passed
 
-Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNa...
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependen...
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 Result: False
 Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 Message: 
-"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be method members that do not call "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNa..." failed:
+"Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" or "System.Void MethodDependencyNamespace.MethodDep... should be method members that do not call any "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependen..." failed:
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 	System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithMultipleDependencies() is not "System.Void TypeDependencyNamespace.BaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass::.ctor()" or "System.Void TypeDependencyNamespace.OtherChildClass::.ctor()" or "System.String TypeDependencyNamespace.BaseClassWithMember::get_BaseClassMember()" or "System.Void TypeDependencyNamespace.BaseClassWithMember::set_BaseClassMember(System.String)" or "System.Void TypeDependencyNamespace.BaseClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.ChildClassWithMember::get_ChildClassMember()" or "System.Void TypeDependencyNamespace.ChildClassWithMember::set_ChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.ChildClassWithMember::.ctor()" or "System.String TypeDependencyNamespace.OtherChildClassWithMember::get_OtherChildClassMember()" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::set_OtherChildClassMember(System.String)" or "System.Void TypeDependencyNamespace.OtherChildClassWithMember::.ctor()" or "System.Void TypeDependencyNamespace.BaseClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClass2::.ctor()" or "System.Void TypeDependencyNamespace.OtherBaseClass::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithMultipleDependencies::.ctor()" or "System.Void TypeDependencyNamespace.GenericBaseClass`1::.ctor()" or "System.Void TypeDependencyNamespace.ChildClassOfGeneric::.ctor()" or "System.Void TypeDependencyNamespace.ClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.OtherClassWithoutDependencies::.ctor()" or "System.Void TypeDependencyNamespace.Issue351::OuterFunc()" or "System.Void TypeDependencyNamespace.Issue351::.ctor()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod1()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod2()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::CalledMethod3()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithoutDependencies()" or "System.Void MethodDependencyNamespace.MethodDependencyClass::.ctor()"
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTest.verified.txt
index c875c55b7..433b1462a 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTest.verified.txt
@@ -2,13 +2,13 @@
 
 ----- Conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
@@ -20,13 +20,13 @@ Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.ClassWithoutDependencies"
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
@@ -100,48 +100,48 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+"Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+"Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any Classes that are "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ChildClass" should not depend on any Classes that are "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+"Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+"Types that are "TypeDependencyNamespace.ChildClass" should not depend on "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
@@ -225,24 +225,18 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "AttributeNamespace.ClassWithoutAttributes"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on "AttributeNamespace.ClassWithoutAttributes"
 Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ----- Predicates -----
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "AttributeNamespace.ClassWithoutAttributes"
-Result: True
-Description: TypeDependencyNamespace.ChildClass passed
-Message: 
-All Evaluations passed
+Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ----- Predicates as conditions -----
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "AttributeNamespace.ClassWithoutAttributes"
-Result: True
-Description: TypeDependencyNamespace.ChildClass passed
-Message: 
-All Evaluations passed
+Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ===== Empty arguments =====
 
@@ -260,15 +254,27 @@ Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any of no types (always true)
+Result: True
+Description: TypeDependencyNamespace.ChildClass passed
+Message: 
+All Evaluations passed
+
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on no types (always true)
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any of no types (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on no types (always true)
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any of no types (always true)
+Result: True
+Description: TypeDependencyNamespace.ChildClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any of no types (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
@@ -276,13 +282,19 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on no types (always true)
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any of no types (always true)
+Result: True
+Description: TypeDependencyNamespace.ChildClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any of no types (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on no types (always true)
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any of no types (always true)
 Result: True
 Description: TypeDependencyNamespace.ChildClass passed
 Message: 
@@ -294,112 +306,112 @@ All Evaluations passed
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ChildClass" should not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Description: TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass is not Types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+"Types that are "TypeDependencyNamespace.ChildClass" should be Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+	TypeDependencyNamespace.ChildClass is not Types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
+Query: Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ChildClass" should be types that do not depend on any "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.BaseClass"" failed:
 	TypeDependencyNamespace.ChildClass is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
@@ -410,130 +422,130 @@ Message:
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any Classes that are "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should not depend on any Classes that are "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on "TypeDependencyNamespace.BaseClassWithMember" and "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Classes that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Classes that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Classes that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Classes that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Classes that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Classes that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Classes that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Classes that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that do not depend on any "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.OtherBaseClass"" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTypesThatTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTypesThatTest.verified.txt
index 6a1651663..257223823 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTypesThatTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotDependOnAnyTypesThatTest.verified.txt
@@ -10,10 +10,10 @@ All Evaluations passed
 
 Query: Types that are "TypeDependencyNamespace.ChildClass" should not depend on any types that are "TypeDependencyNamespace.BaseClass"
 Result: False
-Description: TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+Description: TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 Message: 
 "Types that are "TypeDependencyNamespace.ChildClass" should not depend on any types that are "TypeDependencyNamespace.BaseClass"" failed:
-	TypeDependencyNamespace.ChildClass does depend on TypeDependencyNamespace.BaseClass
+	TypeDependencyNamespace.ChildClass does depend on "TypeDependencyNamespace.BaseClass"
 
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveAnyAttributesTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveAnyAttributesTest.verified.txt
index ed5aca96e..ff91c1716 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveAnyAttributesTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveAnyAttributesTest.verified.txt
@@ -2,25 +2,25 @@
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
@@ -34,25 +34,25 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
@@ -66,25 +66,25 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.UnusedAttribute"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
@@ -100,38 +100,38 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
@@ -147,39 +147,39 @@ Message:
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 
 
 
@@ -194,38 +194,38 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
@@ -243,24 +243,18 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should not have any "TypeDependencyNamespace.BaseClass"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should not have "TypeDependencyNamespace.BaseClass"
 Exception: Type TypeDependencyNamespace.BaseClass does not exist in provided architecture or is no class.
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "TypeDependencyNamespace.BaseClass"
-Result: True
-Description: AttributeNamespace.ClassWithTwoAttributes passed
-Message: 
-All Evaluations passed
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have "TypeDependencyNamespace.BaseClass"
+Exception: Type TypeDependencyNamespace.BaseClass does not exist in provided architecture or is no class.
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "TypeDependencyNamespace.BaseClass"
-Result: True
-Description: AttributeNamespace.ClassWithTwoAttributes passed
-Message: 
-All Evaluations passed
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have "TypeDependencyNamespace.BaseClass"
+Exception: Type TypeDependencyNamespace.BaseClass does not exist in provided architecture or is no class.
 
 ===== Empty arguments =====
 
@@ -278,6 +272,12 @@ Description: AttributeNamespace.ClassWithoutAttributes passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should not have any of no attributes (always true)
+Result: True
+Description: AttributeNamespace.ClassWithoutAttributes passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should not have any Attributes that have full name "NotTheNameOfAnyObject"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
@@ -286,13 +286,19 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be Types that do not have one of no attributes (always true)
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be Types that do not have any of no attributes (always true)
+Result: True
+Description: AttributeNamespace.ClassWithoutAttributes passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be Types that do not have any of no attributes (always true)
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be Types that do not have one of no attributes (always true)
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be Types that do not have any of no attributes (always true)
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Message: 
@@ -306,13 +312,19 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be types that do not have one of no attributes (always true)
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be types that do not have any of no attributes (always true)
+Result: True
+Description: AttributeNamespace.ClassWithoutAttributes passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be types that do not have any of no attributes (always true)
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be types that do not have one of no attributes (always true)
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" should be types that do not have any of no attributes (always true)
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Message: 
@@ -375,39 +387,39 @@ Message:
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 
 
 
@@ -422,38 +434,38 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
 	AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
 	AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
 	AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that do not have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"" failed:
 	AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
@@ -471,7 +483,7 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Result: True
@@ -479,20 +491,20 @@ Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should not have any "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Result: True
@@ -500,20 +512,20 @@ Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 Message: 
-"Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be Types that do not have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that do not have "AttributeNamespace.Attribute1"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Result: True
@@ -521,13 +533,13 @@ Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithoutAttributes passed
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" should be types that do not have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2" or "AttributeNamespace.Attribute3" or "AttributeNamespace.UnusedAttribute" or "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.OnceUsedAttribute" or "AttributeNamespace.ClassWithSingleUniquelyUsedAttribute" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveNameTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveNameTest.verified.txt
index 03ef3e480..0a1ca2c8d 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveNameTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotHaveNameTest.verified.txt
@@ -14,6 +14,24 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name starting with "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name ending with "Test"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name containing "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should not have full name "BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
@@ -26,7 +44,13 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name containing "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have full name starting with "BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have full name ending with "Test"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -38,13 +62,31 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name starting with "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name "TypeDependencyNamespace.ChildClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name ending with "Test"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name matching "^.*\.Child.*$"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name starting with "BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name ending with "Test"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name containing "NotTheNameOfAnyObject"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -64,6 +106,24 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name starting with "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name ending with "Test"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name containing "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name "BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
@@ -76,7 +136,13 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name containing "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name starting with "BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name ending with "Test"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -88,13 +154,31 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name starting with "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name "TypeDependencyNamespace.ChildClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, Public...
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name ending with "Test"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name matching "^.*\.Child.*$"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name starting with "BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name ending with "Test"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name containing "NotTheNameOfAnyObject"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -114,6 +198,24 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name starting with "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name ending with "Test"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name containing "TypeDependencyNamespace"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name "BaseClass"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
@@ -126,7 +228,13 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name containing "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name starting with "BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name ending with "Test"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -138,13 +246,31 @@ Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name starting with "TypeDependencyNamespace"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name "TypeDependencyNamespace.ChildClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, Public...
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name ending with "Test"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name matching "^.*\.Child.*$"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name starting with "BaseClass"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name ending with "Test"
+Result: True
+Description: TypeDependencyNamespace.BaseClass passed
+Message: 
+All Evaluations passed
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name containing "NotTheNameOfAnyObject"
 Result: True
 Description: TypeDependencyNamespace.BaseClass passed
 Message: 
@@ -172,6 +298,33 @@ Message:
 
 
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name starting with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have name starting with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does have name BaseClass
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name ending with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have name ending with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does have name BaseClass
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name containing "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have name containing "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does have name BaseClass
+
+
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should not have full name "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
@@ -190,12 +343,21 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name containing "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have full name starting with "TypeDependencyNamespace"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Description: TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should not have name containing "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass does have name BaseClass
+"Types that are "TypeDependencyNamespace.BaseClass" should not have full name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have full name ending with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have full name ending with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass does have full name TypeDependencyNamespace.BaseClass
 
 
 
@@ -208,21 +370,48 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name starting with "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should not have name starting with "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass does have name BaseClass
+"Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should not have name ending with "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name matching "^.*\.Base.*$"
 Result: False
-Description: TypeDependencyNamespace.BaseClass does have name BaseClass
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should not have name ending with "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass does have name BaseClass
+"Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name matching "^.*\.Base.*$"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name starting with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name containing "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should not have assembly qualified name containing "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass does have assembly qualified name TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
 
 
 
@@ -246,6 +435,33 @@ Message:
 
 
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name starting with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have name starting with "BaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name starting with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have name starting with "BaseClass"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name ending with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have name ending with "BaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name ending with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have name ending with "BaseClass"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name containing "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have name containing "BaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name containing "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have name containing "BaseClass"
+
+
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.BaseClass is not Types that do not have full name "TypeDependencyNamespace.BaseClass"
@@ -264,12 +480,21 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name containing "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name starting with "TypeDependencyNamespace"
 Result: False
-Description: TypeDependencyNamespace.BaseClass is not Types that do not have name containing "BaseClass"
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have full name starting with "TypeDependencyNamespace"
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name containing "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass is not Types that do not have name containing "BaseClass"
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have full name starting with "TypeDependencyNamespace"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name ending with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have full name ending with "BaseClass"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have full name ending with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have full name ending with "BaseClass"
 
 
 
@@ -282,21 +507,48 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name starting with "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicK...
 Result: False
-Description: TypeDependencyNamespace.BaseClass is not Types that do not have name starting with "BaseClass"
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name starting with "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass is not Types that do not have name starting with "BaseClass"
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicK..." failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name ending with "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name matching "^.*\.Base.*$"
 Result: False
-Description: TypeDependencyNamespace.BaseClass is not Types that do not have name ending with "BaseClass"
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name matching "^.*\.Base.*$"
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have name ending with "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass is not Types that do not have name ending with "BaseClass"
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name matching "^.*\.Base.*$"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name matching "^.*\.Base.*$"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name starting with "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name starting with "TypeDependencyNamespace"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name starting with "TypeDependencyNamespace"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name containing "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name containing "TypeDependencyNamespace"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be Types that do not have assembly qualified name containing "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not Types that do not have assembly qualified name containing "TypeDependencyNamespace"
 
 
 
@@ -320,6 +572,33 @@ Message:
 
 
 
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name starting with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name starting with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name ending with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name ending with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name containing "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name containing "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
 Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name "TypeDependencyNamespace.BaseClass"
 Result: False
 Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
@@ -338,12 +617,21 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name containing "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name starting with "TypeDependencyNamespace"
 Result: False
-Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Description: TypeDependencyNamespace.BaseClass is not "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name containing "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name ending with "BaseClass"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have full name ending with "BaseClass"" failed:
+	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
@@ -356,21 +644,48 @@ Message:
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name starting with "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicK...
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name "TypeDependencyNamespace.BaseClass, DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicK..." failed:
+	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name matching "^.*\.Base.*$"
 Result: False
 Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name starting with "BaseClass"" failed:
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name matching "^.*\.Base.*$"" failed:
 	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name ending with "BaseClass"
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name starting with "TypeDependencyNamespace"
 Result: False
-Description: TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Description: TypeDependencyNamespace.BaseClass is not "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have name ending with "BaseClass"" failed:
-	TypeDependencyNamespace.BaseClass is not "TypeDependencyNamespace.ChildClass" or "TypeDependencyNamespace.OtherChildClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.ChildClassWithMember" or "TypeDependencyNamespace.OtherChildClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.ChildClass1" or "TypeDependencyNamespace.ChildClass2" or "TypeDependencyNamespace.ClassWithMultipleDependencies" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ChildClassOfGeneric" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name starting with "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name ending with "DependencyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"" failed:
+	TypeDependencyNamespace.BaseClass is not "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name containing "TypeDependencyNamespace"
+Result: False
+Description: TypeDependencyNamespace.BaseClass is not "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.BaseClass" should be types that do not have assembly qualified name containing "TypeDependencyNamespace"" failed:
+	TypeDependencyNamespace.BaseClass is not "MethodDependencyNamespace.MethodDependencyClass" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyDependOnTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyDependOnTest.verified.txt
index 46255f177..3d4b3c181 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyDependOnTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyDependOnTest.verified.txt
@@ -202,24 +202,12 @@ Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in prov
 ----- Predicates -----
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that only depend on "AttributeNamespace.ClassWithoutAttributes"
-Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that only depend on "AttributeNamespace.ClassWithoutAttributes"
-Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that only depend on "AttributeNamespace.ClassWithoutAttributes"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that only depend on "AttributeNamespace.ClassWithoutAttributes"
-
-
+Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ----- Predicates as conditions -----
 
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that only depend on "AttributeNamespace.ClassWithoutAttributes"
-Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
-Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that only depend on "AttributeNamespace.ClassWithoutAttributes"" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
-
-
+Exception: Type AttributeNamespace.ClassWithoutAttributes does not exist in provided architecture or is no class.
 
 ===== Empty arguments =====
 
@@ -243,6 +231,15 @@ Message:
 
 
 
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should have no dependencies
+Result: False
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+Message: 
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should have no dependencies" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
+
+
+
 Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should only depend on Classes that have full name "NotTheNameOfAnyObject"
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies does depend on System.Object and TypeDependencyNamespace.BaseClassWithMember and TypeDependencyNamespace.OtherBaseClass
@@ -254,21 +251,30 @@ Message:
 
 ----- Predicates -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on no types
+Result: False
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on no types
+Message: 
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on no types" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on no types
+
+
+
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on no types
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on no types
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on no types" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on no types
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on no types
 Result: False
-Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on no types
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that have no dependencies" failed:
-	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that have no dependencies
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be Types that depend on no types" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not Types that depend on no types
 
 
 
@@ -283,20 +289,29 @@ Message:
 
 ----- Predicates as conditions -----
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on no types
+Result: False
+Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+Message: 
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on no types" failed:
+	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
+
+
+
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on no types
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on no types" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
 
-Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies
+Query: Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on no types
 Result: False
 Description: TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 Message: 
-"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that have no dependencies" failed:
+"Types that are "TypeDependencyNamespace.ClassWithMultipleDependencies" should be types that depend on no types" failed:
 	TypeDependencyNamespace.ClassWithMultipleDependencies is not "TypeDependencyNamespace.BaseClass" or "TypeDependencyNamespace.BaseClassWithMember" or "TypeDependencyNamespace.BaseClassWithMultipleDependencies" or "TypeDependencyNamespace.OtherBaseClass" or "TypeDependencyNamespace.GenericBaseClass`1" or "TypeDependencyNamespace.ClassWithoutDependencies" or "TypeDependencyNamespace.OtherClassWithoutDependencies" or "TypeDependencyNamespace.Issue351" or "System.Object" or "System.Void" or "System.String" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Int32" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute" or "System.Collections.Generic.List`1" or "System.Func`2" or "System.IntPtr" or "System.Linq.Enumerable" or "System.Collections.Generic.IEnumerable`1" or "System.Linq.IGrouping`2" or "System.Collections.Generic.IReadOnlyCollection`1" or "System.Collections.Generic.Dictionary`2"
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyHaveAttributesTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyHaveAttributesTest.verified.txt
index d49adceac..19970a804 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyHaveAttributesTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.OnlyHaveAttributesTest.verified.txt
@@ -2,31 +2,31 @@
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have Attributes that are "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have any Attributes that are "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
@@ -34,25 +34,25 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
@@ -66,25 +66,25 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Message: 
@@ -100,86 +100,86 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have Attributes that are "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have any Attributes that are "AttributeNamespace.UnusedAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have Attributes that are "AttributeNamespace.UnusedAttribute"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have any Attributes that are "AttributeNamespace.UnusedAttribute"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "AttributeNamespace.UnusedAttribute"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.UnusedAttribute"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "AttributeNamespace.UnusedAttribute"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.UnusedAttribute"
 
 
 
@@ -196,34 +196,31 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have "TypeDependencyNamespace.BaseClass"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have "TypeDependencyNamespace.BaseClass"
 Exception: Type TypeDependencyNamespace.BaseClass does not exist in provided architecture or is no class.
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "TypeDependencyNamespace.BaseClass"
-Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "TypeDependencyNamespace.BaseClass"
-Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have attribute "TypeDependencyNamespace.BaseClass"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "TypeDependencyNamespace.BaseClass"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have "TypeDependencyNamespace.BaseClass"
+Exception: Type TypeDependencyNamespace.BaseClass does not exist in provided architecture or is no class.
+
+----- Predicates as conditions -----
 
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have "TypeDependencyNamespace.BaseClass"
+Exception: Type TypeDependencyNamespace.BaseClass does not exist in provided architecture or is no class.
 
+===== Empty arguments =====
 
------ Predicates as conditions -----
+----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have attribute "TypeDependencyNamespace.BaseClass"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should have no attributes
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
+Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have attribute "TypeDependencyNamespace.BaseClass"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
-
-
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should have no attributes" failed:
+	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
-===== Empty arguments =====
 
------ Conditions -----
 
 Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should have no attributes
 Result: False
@@ -243,11 +240,11 @@ Message:
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have Attributes that have full name "NotTheNameOfAnyObject"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have any Attributes that have full name "NotTheNameOfAnyObject"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" should does only have Attributes that have full name "NotTheNameOfAnyObject"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should only have any Attributes that have full name "NotTheNameOfAnyObject"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 
 
@@ -272,6 +269,15 @@ Message:
 
 
 
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that have no attributes
+Result: False
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that have no attributes
+Message: 
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that have no attributes" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that have no attributes
+
+
+
 Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be Types that only have Attributes that have full name "NotTheNameOfAnyObject"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have Attributes that have full name "NotTheNameOfAnyObject"
@@ -301,6 +307,15 @@ Message:
 
 
 
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that have no attributes
+Result: False
+Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
+Message: 
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that have no attributes" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
+
+
+
 Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" should be types that only have Attributes that have full name "NotTheNameOfAnyObject"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
@@ -314,31 +329,31 @@ Message:
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should only have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should only have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should only have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should only have any "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should does only have Attributes that are "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should only have any Attributes that are "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -346,25 +361,25 @@ All Evaluations passed
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -378,25 +393,25 @@ All Evaluations passed
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
 All Evaluations passed
 
-Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute1" or "AttributeNamespace.Attribute2"
 Result: True
 Description: AttributeNamespace.ClassWithTwoAttributes passed
 Message: 
@@ -412,24 +427,24 @@ All Evaluations passed
 
 ----- Conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does have attribute AttributeNamespace.Attribute2
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should only have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithTwoAttributes does have attribute AttributeNamespace.Attribute2
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should only have "AttributeNamespace.Attribute2"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes does have attribute AttributeNamespace.Attribute1
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should does only have "AttributeNamespace.Attribute2"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should only have "AttributeNamespace.Attribute2"" failed:
 	AttributeNamespace.ClassWithSingleAttribute does have attribute AttributeNamespace.Attribute1
 	AttributeNamespace.ClassWithTwoAttributes does have attribute AttributeNamespace.Attribute1
 
@@ -437,49 +452,49 @@ Message:
 
 ----- Predicates -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that only have attribute "AttributeNamespace.Attribute1"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that only have "AttributeNamespace.Attribute1"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute1"" failed:
-	AttributeNamespace.ClassWithTwoAttributes is not Types that only have attribute "AttributeNamespace.Attribute1"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute1"" failed:
+	AttributeNamespace.ClassWithTwoAttributes is not Types that only have "AttributeNamespace.Attribute1"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute2"
 Result: False
-Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.Attribute2"
+Description: AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.Attribute2"
 Result: False
-Description: AttributeNamespace.ClassWithTwoAttributes is not Types that only have attribute "AttributeNamespace.Attribute2"
+Description: AttributeNamespace.ClassWithTwoAttributes is not Types that only have "AttributeNamespace.Attribute2"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have attribute "AttributeNamespace.Attribute2"" failed:
-	AttributeNamespace.ClassWithSingleAttribute is not Types that only have attribute "AttributeNamespace.Attribute2"
-	AttributeNamespace.ClassWithTwoAttributes is not Types that only have attribute "AttributeNamespace.Attribute2"
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be Types that only have "AttributeNamespace.Attribute2"" failed:
+	AttributeNamespace.ClassWithSingleAttribute is not Types that only have "AttributeNamespace.Attribute2"
+	AttributeNamespace.ClassWithTwoAttributes is not Types that only have "AttributeNamespace.Attribute2"
 
 
 
 ----- Predicates as conditions -----
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute1"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute1"
 Result: True
 Description: AttributeNamespace.ClassWithSingleAttribute passed
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.ClassWithSingleAttributeWithArguments" or "AttributeNamespace.ClassWithSingleAttributeWithNamedArguments" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute1"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute1"" failed:
 	AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "AttributeNamespace.ClassWithSingleAttributeWithArguments" or "AttributeNamespace.ClassWithSingleAttributeWithNamedArguments" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
 
 
-Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute2"
+Query: Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute2"
 Result: False
 Description: AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 Message: 
-"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have attribute "AttributeNamespace.Attribute2"" failed:
+"Types that are "AttributeNamespace.ClassWithSingleAttribute" or "AttributeNamespace.ClassWithTwoAttributes" should be types that only have "AttributeNamespace.Attribute2"" failed:
 	AttributeNamespace.ClassWithSingleAttribute is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 	AttributeNamespace.ClassWithTwoAttributes is not "AttributeNamespace.ClassWithoutAttributes" or "AttributeNamespace.TypeArgument1" or "AttributeNamespace.TypeArgument2" or "AttributeNamespace.TypeArgument3" or "AttributeNamespace.UnusedTypeArgument" or "System.Attribute" or "System.Object" or "System.Type" or "System.String" or "System.Int32" or "System.Void" or "System.AttributeUsageAttribute" or "System.AttributeTargets" or "System.Runtime.CompilerServices.CompilerGeneratedAttribute" or "System.Runtime.CompilerServices.CompilationRelaxationsAttribute" or "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" or "System.Boolean" or "System.Diagnostics.DebuggableAttribute" or "System.Diagnostics.DebuggableAttribute+DebuggingModes" or "System.Runtime.Versioning.TargetFrameworkAttribute" or "System.Reflection.AssemblyCompanyAttribute" or "System.Reflection.AssemblyConfigurationAttribute" or "System.Reflection.AssemblyFileVersionAttribute" or "System.Reflection.AssemblyInformationalVersionAttribute" or "System.Reflection.AssemblyProductAttribute" or "System.Reflection.AssemblyTitleAttribute"
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.ImplementAnyInterfacesTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.ImplementAnyInterfacesTest.verified.txt
index 3e3c808ef..e10ffdf37 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.ImplementAnyInterfacesTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.ImplementAnyInterfacesTest.verified.txt
@@ -334,7 +334,7 @@ All Evaluations passed
 
 ----- Complex conditions -----
 
-Query: Interfaces that are "InterfaceAssembly.IChildInterface" should implement any interfaces that do not exist (always empty)
+Query: Interfaces that are "InterfaceAssembly.IChildInterface" should implement any interfaces that are any of no objects (always empty)
 Result: True
 Description: InterfaceAssembly.IChildInterface passed
 Message: 
@@ -449,11 +449,11 @@ Message:
 
 ----- Complex conditions -----
 
-Query: Interfaces that are "InterfaceAssembly.IBaseInterface" should implement any interfaces that do not exist (always empty)
+Query: Interfaces that are "InterfaceAssembly.IBaseInterface" should implement any interfaces that are any of no objects (always empty)
 Result: False
 Description: InterfaceAssembly.IBaseInterface does not implement any interface
 Message: 
-"Interfaces that are "InterfaceAssembly.IBaseInterface" should implement any interfaces that do not exist (always empty)" failed:
+"Interfaces that are "InterfaceAssembly.IBaseInterface" should implement any interfaces that are any of no objects (always empty)" failed:
 	InterfaceAssembly.IBaseInterface does not implement any interface
 
 
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.NotImplementAnyInterfacesTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.NotImplementAnyInterfacesTest.verified.txt
index fef065ab1..cd468f61a 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.NotImplementAnyInterfacesTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/TypeSyntaxElementsTests.NotImplementAnyInterfacesTest.verified.txt
@@ -340,7 +340,7 @@ All Evaluations passed
 
 ----- Complex conditions -----
 
-Query: Interfaces that are "InterfaceAssembly.IBaseInterface" should not implement any interfaces that do not exist (always empty)
+Query: Interfaces that are "InterfaceAssembly.IBaseInterface" should not implement any interfaces that are any of no objects (always empty)
 Result: True
 Description: InterfaceAssembly.IBaseInterface passed
 Message: 
@@ -464,11 +464,11 @@ Message:
 
 ----- Complex conditions -----
 
-Query: Interfaces that are "InterfaceAssembly.IChildInterface" should not implement any interfaces that do not exist (always empty)
+Query: Interfaces that are "InterfaceAssembly.IChildInterface" should not implement any interfaces that are any of no objects (always empty)
 Result: False
 Description: InterfaceAssembly.IChildInterface does implement InterfaceAssembly.IBaseInterface
 Message: 
-"Interfaces that are "InterfaceAssembly.IChildInterface" should not implement any interfaces that do not exist (always empty)" failed:
+"Interfaces that are "InterfaceAssembly.IChildInterface" should not implement any interfaces that are any of no objects (always empty)" failed:
 	InterfaceAssembly.IChildInterface does implement InterfaceAssembly.IBaseInterface
 
 

From ad21b7b98f39e3022e8d64b3d645f6d73ce18468 Mon Sep 17 00:00:00 2001
From: Alexander Linne <alexander.linne@tngtech.com>
Date: Fri, 26 Sep 2025 16:56:01 +0200
Subject: [PATCH 2/2] Add missing assertion in ObjectSyntaxElementsTests

Signed-off-by: Alexander Linne <alexander.linne@tngtech.com>
---
 .../Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs  | 4 ++--
 ...yntaxElementsTests.HaveAnyAttributesTest.verified.txt | 9 +++++++++
 ...ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt | 6 ++++++
 3 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs b/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs
index c2861b3bf..625cd908f 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs
@@ -648,7 +648,7 @@ public async Task HaveAnyAttributesTest()
         should = Types().That().Are(helper.ClassWithTwoAttributes).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.HaveAnyAttributes();
+        should.HaveAnyAttributes().AssertOnlyViolations(helper);
         should.HaveAnyAttributes(new List<Attribute>()).AssertOnlyViolations(helper);
         should.HaveAnyAttributes(new List<System.Type>()).AssertOnlyViolations(helper);
         should.HaveAnyAttributes(Attributes().That().HaveFullName(helper.NonExistentObjectName)).AssertOnlyViolations(helper);
@@ -1650,7 +1650,7 @@ public async Task NotCallAnyTest()
         should = MethodMembers().That().Are(helper.MethodWithSingleDependency).Should();
 
         helper.AddSnapshotSubHeader("Conditions");
-        should.NotCallAny();
+        should.NotCallAny().AssertNoViolations(helper);
         should.NotCallAny(new List<MethodMember>()).AssertNoViolations(helper);
 
         helper.AddSnapshotSubHeader("Predicates");
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt
index 8c351ccda..38f5e0e2c 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.HaveAnyAttributesTest.verified.txt
@@ -261,6 +261,15 @@ Message:
 
 
 
+Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any of no attributes (impossible)
+Result: False
+Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
+Message: 
+"Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any of no attributes (impossible)" failed:
+	AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
+
+
+
 Query: Types that are "AttributeNamespace.ClassWithTwoAttributes" should have any Attributes that have full name "NotTheNameOfAnyObject"
 Result: False
 Description: AttributeNamespace.ClassWithTwoAttributes only has attributes "AttributeNamespace.Attribute1" and "AttributeNamespace.Attribute2"
diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt
index 85664aa96..92e45d7f7 100644
--- a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt
+++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.NotCallAnyTest.verified.txt
@@ -159,6 +159,12 @@ Description: System.Void MethodDependencyNamespace.MethodDependencyClass::Method
 Message: 
 All Evaluations passed
 
+Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should not call any of no methods (always true)
+Result: True
+Description: System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency() passed
+Message: 
+All Evaluations passed
+
 ----- Predicates -----
 
 Query: Method members that are "System.Void MethodDependencyNamespace.MethodDependencyClass::MethodWithSingleDependency()" should be Method members that do not call any of no methods (always true)