private void ShouldBeEquivalent(IConditionExpression actual, IConditionExpression expected)
        {
            if (expected == null)
            {
                actual.Should().BeNull();
            }
            else
            {
                actual.Should().NotBeNull();
                switch (expected)
                {
                case LeafExpression expectedLeaf:
                {
                    var actualLeaf = actual as LeafExpression;
                    actualLeaf.Should().NotBeNull();
                    ShouldBeEquivalent(actualLeaf, expectedLeaf);
                    break;
                }

                case AllOfExpression expectedAll:
                {
                    var actualAll = actual as AllOfExpression;
                    actualAll.Should().NotBeNull();
                    ShouldBeEquivalent(actualAll, expectedAll);
                    break;
                }

                case AnyOfExpression expectedAny:
                {
                    var actualAny = actual as AnyOfExpression;
                    actualAny.Should().NotBeNull();
                    ShouldBeEquivalent(actualAny, expectedAny);
                    break;
                }

                case NotExpression expectedNot:
                {
                    var actualNot = actual as NotExpression;
                    actualNot.Should().NotBeNull();
                    ShouldBeEquivalent(actualNot, expectedNot);
                    break;
                }
                }
            }
        }