Esempio n. 1
0
        public static bool IsNullConstantPattern(this PatternSyntaxWrapper pattern)
        {
            if (!ConstantPatternSyntaxWrapper.IsInstance(pattern))
            {
                return(false);
            }

            var constantPattern = (ConstantPatternSyntaxWrapper)pattern;

            return(constantPattern.Expression.IsKind(SyntaxKind.NullLiteralExpression));
        }
Esempio n. 2
0
        public void TestIsInstance()
        {
            Assert.False(PatternSyntaxWrapper.IsInstance(null));
            Assert.False(PatternSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));

            var constantPatternSyntax = SyntaxFactory.ConstantPattern(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));

            Assert.True(PatternSyntaxWrapper.IsInstance(constantPatternSyntax));

            var declarationPatternSyntax = SyntaxFactory.DeclarationPattern(
                SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
                SyntaxFactory.DiscardDesignation());

            Assert.True(PatternSyntaxWrapper.IsInstance(declarationPatternSyntax));
        }
        public void TestConversionsNull()
        {
            var syntaxNode = default(SyntaxNode);
            var declarationPatternSyntax = (DeclarationPatternSyntaxWrapper)syntaxNode;

            PatternSyntaxWrapper patternSyntax = declarationPatternSyntax;

            Assert.Null(patternSyntax.SyntaxNode);

            declarationPatternSyntax = (DeclarationPatternSyntaxWrapper)patternSyntax;
            Assert.Null(declarationPatternSyntax.SyntaxNode);

            SyntaxNode syntax = declarationPatternSyntax;

            Assert.Null(syntax);
        }
        public void TestConversions()
        {
            var syntaxNode            = SyntaxFactory.ConstantPattern(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
            var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;

            PatternSyntaxWrapper patternSyntax = constantPatternSyntax;

            Assert.Same(syntaxNode, patternSyntax.SyntaxNode);

            constantPatternSyntax = (ConstantPatternSyntaxWrapper)patternSyntax;
            Assert.Same(syntaxNode, constantPatternSyntax.SyntaxNode);

            SyntaxNode syntax = constantPatternSyntax;

            Assert.Same(syntaxNode, syntax);
        }
        public void TestConversionsNull()
        {
            var syntaxNode            = default(SyntaxNode);
            var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;

            PatternSyntaxWrapper patternSyntax = constantPatternSyntax;

            Assert.Null(patternSyntax.SyntaxNode);

            constantPatternSyntax = (ConstantPatternSyntaxWrapper)patternSyntax;
            Assert.Null(constantPatternSyntax.SyntaxNode);

            SyntaxNode syntax = constantPatternSyntax;

            Assert.Null(syntax);
        }
Esempio n. 6
0
        public void TestConversions()
        {
            var syntaxNode = SyntaxFactory.DeclarationPattern(
                SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
                SyntaxFactory.DiscardDesignation());
            var declarationPatternSyntax = (DeclarationPatternSyntaxWrapper)syntaxNode;

            PatternSyntaxWrapper patternSyntax = declarationPatternSyntax;

            Assert.Same(syntaxNode, patternSyntax.SyntaxNode);

            declarationPatternSyntax = (DeclarationPatternSyntaxWrapper)patternSyntax;
            Assert.Same(syntaxNode, declarationPatternSyntax.SyntaxNode);

            SyntaxNode syntax = declarationPatternSyntax;

            Assert.Same(syntaxNode, syntax);
        }
 public void TestIsInstance()
 {
     Assert.False(PatternSyntaxWrapper.IsInstance(null));
     Assert.False(PatternSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
 }