' Definition of syntax model.
' DO NOT HAND EDIT
 
Imports System.Collections.Generic
Imports System.Collections.Immutable
Imports System.Runtime.CompilerServices
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Imports Roslyn.Utilities
Imports Xunit
' Tests for parse trees.
' DO NOT HAND EDIT
 
 
Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
 
Partial Public Class GeneratedTests
 
#region "Green Factory Calls"
        Private Shared Function GenerateGreenEmptyStatement() As InternalSyntax.EmptyStatementSyntax
            return InternalSyntax.SyntaxFactory.EmptyStatement(new InternalSyntax.PunctuationSyntax(SyntaxKind.EmptyToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndIfStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndIfStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndUsingStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndUsingStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.UsingKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndWithStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndWithStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WithKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndSelectStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndSelectStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SelectKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndStructureStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndStructureStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.StructureKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndEnumStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndEnumStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.EnumKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndInterfaceStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndInterfaceStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.InterfaceKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndClassStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndClassStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ClassKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndModuleStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndModuleStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ModuleKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndNamespaceStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndNamespaceStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.NamespaceKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndSubStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndSubStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndFunctionStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndFunctionStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.FunctionKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndGetStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndGetStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.GetKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndSetStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndSetStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SetKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndPropertyStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndPropertyStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.PropertyKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndOperatorStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndOperatorStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.OperatorKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndEventStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndEventStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.EventKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndAddHandlerStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndAddHandlerStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.AddHandlerKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndRemoveHandlerStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndRemoveHandlerStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.RemoveHandlerKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndRaiseEventStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndRaiseEventStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.RaiseEventKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndWhileStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndWhileStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndTryStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndTryStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.TryKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndSyncLockStatement() As InternalSyntax.EndBlockStatementSyntax
            return InternalSyntax.SyntaxFactory.EndSyncLockStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SyncLockKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenCompilationUnit() As InternalSyntax.CompilationUnitSyntax
            return InternalSyntax.SyntaxFactory.CompilationUnit(Nothing, Nothing, Nothing, Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.EndOfFileToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenOptionStatement() As InternalSyntax.OptionStatementSyntax
            return InternalSyntax.SyntaxFactory.OptionStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.OptionKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ExplicitKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenImportsStatement() As InternalSyntax.ImportsStatementSyntax
            return InternalSyntax.SyntaxFactory.ImportsStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ImportsKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSimpleImportsClause() As InternalSyntax.SimpleImportsClauseSyntax
            return InternalSyntax.SyntaxFactory.SimpleImportsClause(Nothing, GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenImportAliasClause() As InternalSyntax.ImportAliasClauseSyntax
            return InternalSyntax.SyntaxFactory.ImportAliasClause(GenerateGreenIdentifierToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlNamespaceImportsClause() As InternalSyntax.XmlNamespaceImportsClauseSyntax
            return InternalSyntax.SyntaxFactory.XmlNamespaceImportsClause(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), GenerateGreenXmlAttribute(), new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenNamespaceBlock() As InternalSyntax.NamespaceBlockSyntax
            return InternalSyntax.SyntaxFactory.NamespaceBlock(GenerateGreenNamespaceStatement(), Nothing, GenerateGreenEndNamespaceStatement())
        End Function
 
        Private Shared Function GenerateGreenNamespaceStatement() As InternalSyntax.NamespaceStatementSyntax
            return InternalSyntax.SyntaxFactory.NamespaceStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.NamespaceKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenModuleBlock() As InternalSyntax.ModuleBlockSyntax
            return InternalSyntax.SyntaxFactory.ModuleBlock(GenerateGreenModuleStatement(), Nothing, Nothing, Nothing, GenerateGreenEndModuleStatement())
        End Function
 
        Private Shared Function GenerateGreenStructureBlock() As InternalSyntax.StructureBlockSyntax
            return InternalSyntax.SyntaxFactory.StructureBlock(GenerateGreenStructureStatement(), Nothing, Nothing, Nothing, GenerateGreenEndStructureStatement())
        End Function
 
        Private Shared Function GenerateGreenInterfaceBlock() As InternalSyntax.InterfaceBlockSyntax
            return InternalSyntax.SyntaxFactory.InterfaceBlock(GenerateGreenInterfaceStatement(), Nothing, Nothing, Nothing, GenerateGreenEndInterfaceStatement())
        End Function
 
        Private Shared Function GenerateGreenClassBlock() As InternalSyntax.ClassBlockSyntax
            return InternalSyntax.SyntaxFactory.ClassBlock(GenerateGreenClassStatement(), Nothing, Nothing, Nothing, GenerateGreenEndClassStatement())
        End Function
 
        Private Shared Function GenerateGreenEnumBlock() As InternalSyntax.EnumBlockSyntax
            return InternalSyntax.SyntaxFactory.EnumBlock(GenerateGreenEnumStatement(), Nothing, GenerateGreenEndEnumStatement())
        End Function
 
        Private Shared Function GenerateGreenInheritsStatement() As InternalSyntax.InheritsStatementSyntax
            return InternalSyntax.SyntaxFactory.InheritsStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.InheritsKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenImplementsStatement() As InternalSyntax.ImplementsStatementSyntax
            return InternalSyntax.SyntaxFactory.ImplementsStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ImplementsKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenModuleStatement() As InternalSyntax.ModuleStatementSyntax
            return InternalSyntax.SyntaxFactory.ModuleStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.ModuleKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenStructureStatement() As InternalSyntax.StructureStatementSyntax
            return InternalSyntax.SyntaxFactory.StructureStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.StructureKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenInterfaceStatement() As InternalSyntax.InterfaceStatementSyntax
            return InternalSyntax.SyntaxFactory.InterfaceStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.InterfaceKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenClassStatement() As InternalSyntax.ClassStatementSyntax
            return InternalSyntax.SyntaxFactory.ClassStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.ClassKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenEnumStatement() As InternalSyntax.EnumStatementSyntax
            return InternalSyntax.SyntaxFactory.EnumStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.EnumKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenTypeParameterList() As InternalSyntax.TypeParameterListSyntax
            return InternalSyntax.SyntaxFactory.TypeParameterList(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.OfKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTypeParameter() As InternalSyntax.TypeParameterSyntax
            return InternalSyntax.SyntaxFactory.TypeParameter(Nothing, GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenTypeParameterSingleConstraintClause() As InternalSyntax.TypeParameterSingleConstraintClauseSyntax
            return InternalSyntax.SyntaxFactory.TypeParameterSingleConstraintClause(new InternalSyntax.KeywordSyntax(SyntaxKind.AsKeyword, String.Empty, Nothing, Nothing), GenerateGreenNewConstraint())
        End Function
 
        Private Shared Function GenerateGreenTypeParameterMultipleConstraintClause() As InternalSyntax.TypeParameterMultipleConstraintClauseSyntax
            return InternalSyntax.SyntaxFactory.TypeParameterMultipleConstraintClause(new InternalSyntax.KeywordSyntax(SyntaxKind.AsKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenBraceToken, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseBraceToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenNewConstraint() As InternalSyntax.SpecialConstraintSyntax
            return InternalSyntax.SyntaxFactory.NewConstraint(new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenClassConstraint() As InternalSyntax.SpecialConstraintSyntax
            return InternalSyntax.SyntaxFactory.ClassConstraint(new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenStructureConstraint() As InternalSyntax.SpecialConstraintSyntax
            return InternalSyntax.SyntaxFactory.StructureConstraint(new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTypeConstraint() As InternalSyntax.TypeConstraintSyntax
            return InternalSyntax.SyntaxFactory.TypeConstraint(GenerateGreenTupleType())
        End Function
 
        Private Shared Function GenerateGreenEnumMemberDeclaration() As InternalSyntax.EnumMemberDeclarationSyntax
            return InternalSyntax.SyntaxFactory.EnumMemberDeclaration(Nothing, GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSubBlock() As InternalSyntax.MethodBlockSyntax
            return InternalSyntax.SyntaxFactory.SubBlock(GenerateGreenSubStatement(), Nothing, GenerateGreenEndSubStatement())
        End Function
 
        Private Shared Function GenerateGreenFunctionBlock() As InternalSyntax.MethodBlockSyntax
            return InternalSyntax.SyntaxFactory.FunctionBlock(GenerateGreenFunctionStatement(), Nothing, GenerateGreenEndFunctionStatement())
        End Function
 
        Private Shared Function GenerateGreenConstructorBlock() As InternalSyntax.ConstructorBlockSyntax
            return InternalSyntax.SyntaxFactory.ConstructorBlock(GenerateGreenSubNewStatement(), Nothing, GenerateGreenEndSubStatement())
        End Function
 
        Private Shared Function GenerateGreenOperatorBlock() As InternalSyntax.OperatorBlockSyntax
            return InternalSyntax.SyntaxFactory.OperatorBlock(GenerateGreenOperatorStatement(), Nothing, GenerateGreenEndOperatorStatement())
        End Function
 
        Private Shared Function GenerateGreenGetAccessorBlock() As InternalSyntax.AccessorBlockSyntax
            return InternalSyntax.SyntaxFactory.GetAccessorBlock(GenerateGreenGetAccessorStatement(), Nothing, GenerateGreenEndGetStatement())
        End Function
 
        Private Shared Function GenerateGreenSetAccessorBlock() As InternalSyntax.AccessorBlockSyntax
            return InternalSyntax.SyntaxFactory.SetAccessorBlock(GenerateGreenSetAccessorStatement(), Nothing, GenerateGreenEndSetStatement())
        End Function
 
        Private Shared Function GenerateGreenAddHandlerAccessorBlock() As InternalSyntax.AccessorBlockSyntax
            return InternalSyntax.SyntaxFactory.AddHandlerAccessorBlock(GenerateGreenAddHandlerAccessorStatement(), Nothing, GenerateGreenEndAddHandlerStatement())
        End Function
 
        Private Shared Function GenerateGreenRemoveHandlerAccessorBlock() As InternalSyntax.AccessorBlockSyntax
            return InternalSyntax.SyntaxFactory.RemoveHandlerAccessorBlock(GenerateGreenRemoveHandlerAccessorStatement(), Nothing, GenerateGreenEndRemoveHandlerStatement())
        End Function
 
        Private Shared Function GenerateGreenRaiseEventAccessorBlock() As InternalSyntax.AccessorBlockSyntax
            return InternalSyntax.SyntaxFactory.RaiseEventAccessorBlock(GenerateGreenRaiseEventAccessorStatement(), Nothing, GenerateGreenEndRaiseEventStatement())
        End Function
 
        Private Shared Function GenerateGreenPropertyBlock() As InternalSyntax.PropertyBlockSyntax
            return InternalSyntax.SyntaxFactory.PropertyBlock(GenerateGreenPropertyStatement(), GenerateGreenGetAccessorBlock(), GenerateGreenEndPropertyStatement())
        End Function
 
        Private Shared Function GenerateGreenEventBlock() As InternalSyntax.EventBlockSyntax
            return InternalSyntax.SyntaxFactory.EventBlock(GenerateGreenEventStatement(), GenerateGreenAddHandlerAccessorBlock(), GenerateGreenEndEventStatement())
        End Function
 
        Private Shared Function GenerateGreenParameterList() As InternalSyntax.ParameterListSyntax
            return InternalSyntax.SyntaxFactory.ParameterList(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenSubStatement() As InternalSyntax.MethodStatementSyntax
            return InternalSyntax.SyntaxFactory.SubStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenFunctionStatement() As InternalSyntax.MethodStatementSyntax
            return InternalSyntax.SyntaxFactory.FunctionStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.FunctionKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenSubNewStatement() As InternalSyntax.SubNewStatementSyntax
            return InternalSyntax.SyntaxFactory.SubNewStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenDeclareSubStatement() As InternalSyntax.DeclareStatementSyntax
            return InternalSyntax.SyntaxFactory.DeclareSubStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.DeclareKeyword, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), new InternalSyntax.KeywordSyntax(SyntaxKind.LibKeyword, String.Empty, Nothing, Nothing), GenerateGreenCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenDeclareFunctionStatement() As InternalSyntax.DeclareStatementSyntax
            return InternalSyntax.SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.DeclareKeyword, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.FunctionKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), new InternalSyntax.KeywordSyntax(SyntaxKind.LibKeyword, String.Empty, Nothing, Nothing), GenerateGreenCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenDelegateSubStatement() As InternalSyntax.DelegateStatementSyntax
            return InternalSyntax.SyntaxFactory.DelegateSubStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.DelegateKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenDelegateFunctionStatement() As InternalSyntax.DelegateStatementSyntax
            return InternalSyntax.SyntaxFactory.DelegateFunctionStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.DelegateKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.FunctionKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenEventStatement() As InternalSyntax.EventStatementSyntax
            return InternalSyntax.SyntaxFactory.EventStatement(Nothing, Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.EventKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenOperatorStatement() As InternalSyntax.OperatorStatementSyntax
            return InternalSyntax.SyntaxFactory.OperatorStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.OperatorKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.CTypeKeyword, String.Empty, Nothing, Nothing), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenPropertyStatement() As InternalSyntax.PropertyStatementSyntax
            return InternalSyntax.SyntaxFactory.PropertyStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.PropertyKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenGetAccessorStatement() As InternalSyntax.AccessorStatementSyntax
            return InternalSyntax.SyntaxFactory.GetAccessorStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.GetKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSetAccessorStatement() As InternalSyntax.AccessorStatementSyntax
            return InternalSyntax.SyntaxFactory.SetAccessorStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.SetKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenAddHandlerAccessorStatement() As InternalSyntax.AccessorStatementSyntax
            return InternalSyntax.SyntaxFactory.AddHandlerAccessorStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.AddHandlerKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenRemoveHandlerAccessorStatement() As InternalSyntax.AccessorStatementSyntax
            return InternalSyntax.SyntaxFactory.RemoveHandlerAccessorStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.RemoveHandlerKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenRaiseEventAccessorStatement() As InternalSyntax.AccessorStatementSyntax
            return InternalSyntax.SyntaxFactory.RaiseEventAccessorStatement(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.RaiseEventKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenImplementsClause() As InternalSyntax.ImplementsClauseSyntax
            return InternalSyntax.SyntaxFactory.ImplementsClause(new InternalSyntax.KeywordSyntax(SyntaxKind.ImplementsKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenHandlesClause() As InternalSyntax.HandlesClauseSyntax
            return InternalSyntax.SyntaxFactory.HandlesClause(new InternalSyntax.KeywordSyntax(SyntaxKind.HandlesKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenKeywordEventContainer() As InternalSyntax.KeywordEventContainerSyntax
            return InternalSyntax.SyntaxFactory.KeywordEventContainer(new InternalSyntax.KeywordSyntax(SyntaxKind.MyBaseKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenWithEventsEventContainer() As InternalSyntax.WithEventsEventContainerSyntax
            return InternalSyntax.SyntaxFactory.WithEventsEventContainer(GenerateGreenIdentifierToken())
        End Function
 
        Private Shared Function GenerateGreenWithEventsPropertyEventContainer() As InternalSyntax.WithEventsPropertyEventContainerSyntax
            return InternalSyntax.SyntaxFactory.WithEventsPropertyEventContainer(GenerateGreenWithEventsEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenHandlesClauseItem() As InternalSyntax.HandlesClauseItemSyntax
            return InternalSyntax.SyntaxFactory.HandlesClauseItem(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenIncompleteMember() As InternalSyntax.IncompleteMemberSyntax
            return InternalSyntax.SyntaxFactory.IncompleteMember(Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenFieldDeclaration() As InternalSyntax.FieldDeclarationSyntax
            return InternalSyntax.SyntaxFactory.FieldDeclaration(Nothing, Nothing, New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenVariableDeclarator() As InternalSyntax.VariableDeclaratorSyntax
            return InternalSyntax.SyntaxFactory.VariableDeclarator(New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenSimpleAsClause() As InternalSyntax.SimpleAsClauseSyntax
            return InternalSyntax.SyntaxFactory.SimpleAsClause(new InternalSyntax.KeywordSyntax(SyntaxKind.AsKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenTupleType())
        End Function
 
        Private Shared Function GenerateGreenAsNewClause() As InternalSyntax.AsNewClauseSyntax
            return InternalSyntax.SyntaxFactory.AsNewClause(new InternalSyntax.KeywordSyntax(SyntaxKind.AsKeyword, String.Empty, Nothing, Nothing), GenerateGreenObjectCreationExpression())
        End Function
 
        Private Shared Function GenerateGreenObjectMemberInitializer() As InternalSyntax.ObjectMemberInitializerSyntax
            return InternalSyntax.SyntaxFactory.ObjectMemberInitializer(new InternalSyntax.KeywordSyntax(SyntaxKind.WithKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenBraceToken, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseBraceToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenObjectCollectionInitializer() As InternalSyntax.ObjectCollectionInitializerSyntax
            return InternalSyntax.SyntaxFactory.ObjectCollectionInitializer(new InternalSyntax.KeywordSyntax(SyntaxKind.FromKeyword, String.Empty, Nothing, Nothing), GenerateGreenCollectionInitializer())
        End Function
 
        Private Shared Function GenerateGreenInferredFieldInitializer() As InternalSyntax.InferredFieldInitializerSyntax
            return InternalSyntax.SyntaxFactory.InferredFieldInitializer(Nothing, GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenNamedFieldInitializer() As InternalSyntax.NamedFieldInitializerSyntax
            return InternalSyntax.SyntaxFactory.NamedFieldInitializer(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenEqualsValue() As InternalSyntax.EqualsValueSyntax
            return InternalSyntax.SyntaxFactory.EqualsValue(new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenParameter() As InternalSyntax.ParameterSyntax
            return InternalSyntax.SyntaxFactory.Parameter(Nothing, Nothing, GenerateGreenModifiedIdentifier(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenModifiedIdentifier() As InternalSyntax.ModifiedIdentifierSyntax
            return InternalSyntax.SyntaxFactory.ModifiedIdentifier(GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenArrayRankSpecifier() As InternalSyntax.ArrayRankSpecifierSyntax
            return InternalSyntax.SyntaxFactory.ArrayRankSpecifier(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenAttributeList() As InternalSyntax.AttributeListSyntax
            return InternalSyntax.SyntaxFactory.AttributeList(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenAttribute() As InternalSyntax.AttributeSyntax
            return InternalSyntax.SyntaxFactory.Attribute(Nothing, GenerateGreenPredefinedType(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenAttributeTarget() As InternalSyntax.AttributeTargetSyntax
            return InternalSyntax.SyntaxFactory.AttributeTarget(new InternalSyntax.KeywordSyntax(SyntaxKind.AssemblyKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.ColonToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenAttributesStatement() As InternalSyntax.AttributesStatementSyntax
            return InternalSyntax.SyntaxFactory.AttributesStatement(Nothing)
        End Function
 
        Private Shared Function GenerateGreenExpressionStatement() As InternalSyntax.ExpressionStatementSyntax
            return InternalSyntax.SyntaxFactory.ExpressionStatement(GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenPrintStatement() As InternalSyntax.PrintStatementSyntax
            return InternalSyntax.SyntaxFactory.PrintStatement(new InternalSyntax.PunctuationSyntax(SyntaxKind.QuestionToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenWhileBlock() As InternalSyntax.WhileBlockSyntax
            return InternalSyntax.SyntaxFactory.WhileBlock(GenerateGreenWhileStatement(), Nothing, GenerateGreenEndWhileStatement())
        End Function
 
        Private Shared Function GenerateGreenUsingBlock() As InternalSyntax.UsingBlockSyntax
            return InternalSyntax.SyntaxFactory.UsingBlock(GenerateGreenUsingStatement(), Nothing, GenerateGreenEndUsingStatement())
        End Function
 
        Private Shared Function GenerateGreenSyncLockBlock() As InternalSyntax.SyncLockBlockSyntax
            return InternalSyntax.SyntaxFactory.SyncLockBlock(GenerateGreenSyncLockStatement(), Nothing, GenerateGreenEndSyncLockStatement())
        End Function
 
        Private Shared Function GenerateGreenWithBlock() As InternalSyntax.WithBlockSyntax
            return InternalSyntax.SyntaxFactory.WithBlock(GenerateGreenWithStatement(), Nothing, GenerateGreenEndWithStatement())
        End Function
 
        Private Shared Function GenerateGreenLocalDeclarationStatement() As InternalSyntax.LocalDeclarationStatementSyntax
            return InternalSyntax.SyntaxFactory.LocalDeclarationStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.StaticKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenLabelStatement() As InternalSyntax.LabelStatementSyntax
            return InternalSyntax.SyntaxFactory.LabelStatement(GenerateGreenIdentifierToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.ColonToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenGoToStatement() As InternalSyntax.GoToStatementSyntax
            return InternalSyntax.SyntaxFactory.GoToStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.GoToKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierLabel())
        End Function
 
        Private Shared Function GenerateGreenIdentifierLabel() As InternalSyntax.LabelSyntax
            return InternalSyntax.SyntaxFactory.IdentifierLabel(GenerateGreenIdentifierToken())
        End Function
 
        Private Shared Function GenerateGreenNumericLabel() As InternalSyntax.LabelSyntax
            return InternalSyntax.SyntaxFactory.NumericLabel(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenNextLabel() As InternalSyntax.LabelSyntax
            return InternalSyntax.SyntaxFactory.NextLabel(new InternalSyntax.KeywordSyntax(SyntaxKind.NextKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenStopStatement() As InternalSyntax.StopOrEndStatementSyntax
            return InternalSyntax.SyntaxFactory.StopStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.StopKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndStatement() As InternalSyntax.StopOrEndStatementSyntax
            return InternalSyntax.SyntaxFactory.EndStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.StopKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitDoStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitDoStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.DoKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitForStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitForStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ForKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitSubStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitSubStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitFunctionStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitFunctionStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.FunctionKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitOperatorStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitOperatorStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.OperatorKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitPropertyStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitPropertyStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.PropertyKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitTryStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitTryStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.TryKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitSelectStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitSelectStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.SelectKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExitWhileStatement() As InternalSyntax.ExitStatementSyntax
            return InternalSyntax.SyntaxFactory.ExitWhileStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ExitKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenContinueWhileStatement() As InternalSyntax.ContinueStatementSyntax
            return InternalSyntax.SyntaxFactory.ContinueWhileStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ContinueKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenContinueDoStatement() As InternalSyntax.ContinueStatementSyntax
            return InternalSyntax.SyntaxFactory.ContinueDoStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ContinueKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.DoKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenContinueForStatement() As InternalSyntax.ContinueStatementSyntax
            return InternalSyntax.SyntaxFactory.ContinueForStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ContinueKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ForKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenReturnStatement() As InternalSyntax.ReturnStatementSyntax
            return InternalSyntax.SyntaxFactory.ReturnStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ReturnKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSingleLineIfStatement() As InternalSyntax.SingleLineIfStatementSyntax
            return InternalSyntax.SyntaxFactory.SingleLineIfStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.ThenKeyword, String.Empty, Nothing, Nothing), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenSingleLineElseClause() As InternalSyntax.SingleLineElseClauseSyntax
            return InternalSyntax.SyntaxFactory.SingleLineElseClause(new InternalSyntax.KeywordSyntax(SyntaxKind.ElseKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenMultiLineIfBlock() As InternalSyntax.MultiLineIfBlockSyntax
            return InternalSyntax.SyntaxFactory.MultiLineIfBlock(GenerateGreenIfStatement(), Nothing, Nothing, Nothing, GenerateGreenEndIfStatement())
        End Function
 
        Private Shared Function GenerateGreenIfStatement() As InternalSyntax.IfStatementSyntax
            return InternalSyntax.SyntaxFactory.IfStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenElseIfBlock() As InternalSyntax.ElseIfBlockSyntax
            return InternalSyntax.SyntaxFactory.ElseIfBlock(GenerateGreenElseIfStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenElseIfStatement() As InternalSyntax.ElseIfStatementSyntax
            return InternalSyntax.SyntaxFactory.ElseIfStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ElseIfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenElseBlock() As InternalSyntax.ElseBlockSyntax
            return InternalSyntax.SyntaxFactory.ElseBlock(GenerateGreenElseStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenElseStatement() As InternalSyntax.ElseStatementSyntax
            return InternalSyntax.SyntaxFactory.ElseStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ElseKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTryBlock() As InternalSyntax.TryBlockSyntax
            return InternalSyntax.SyntaxFactory.TryBlock(GenerateGreenTryStatement(), Nothing, Nothing, Nothing, GenerateGreenEndTryStatement())
        End Function
 
        Private Shared Function GenerateGreenTryStatement() As InternalSyntax.TryStatementSyntax
            return InternalSyntax.SyntaxFactory.TryStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.TryKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenCatchBlock() As InternalSyntax.CatchBlockSyntax
            return InternalSyntax.SyntaxFactory.CatchBlock(GenerateGreenCatchStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenCatchStatement() As InternalSyntax.CatchStatementSyntax
            return InternalSyntax.SyntaxFactory.CatchStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.CatchKeyword, String.Empty, Nothing, Nothing), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenCatchFilterClause() As InternalSyntax.CatchFilterClauseSyntax
            return InternalSyntax.SyntaxFactory.CatchFilterClause(new InternalSyntax.KeywordSyntax(SyntaxKind.WhenKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenFinallyBlock() As InternalSyntax.FinallyBlockSyntax
            return InternalSyntax.SyntaxFactory.FinallyBlock(GenerateGreenFinallyStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenFinallyStatement() As InternalSyntax.FinallyStatementSyntax
            return InternalSyntax.SyntaxFactory.FinallyStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.FinallyKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenErrorStatement() As InternalSyntax.ErrorStatementSyntax
            return InternalSyntax.SyntaxFactory.ErrorStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ErrorKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenOnErrorGoToZeroStatement() As InternalSyntax.OnErrorGoToStatementSyntax
            return InternalSyntax.SyntaxFactory.OnErrorGoToZeroStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.OnKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ErrorKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.GoToKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenIdentifierLabel())
        End Function
 
        Private Shared Function GenerateGreenOnErrorGoToMinusOneStatement() As InternalSyntax.OnErrorGoToStatementSyntax
            return InternalSyntax.SyntaxFactory.OnErrorGoToMinusOneStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.OnKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ErrorKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.GoToKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenIdentifierLabel())
        End Function
 
        Private Shared Function GenerateGreenOnErrorGoToLabelStatement() As InternalSyntax.OnErrorGoToStatementSyntax
            return InternalSyntax.SyntaxFactory.OnErrorGoToLabelStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.OnKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ErrorKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.GoToKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenIdentifierLabel())
        End Function
 
        Private Shared Function GenerateGreenOnErrorResumeNextStatement() As InternalSyntax.OnErrorResumeNextStatementSyntax
            return InternalSyntax.SyntaxFactory.OnErrorResumeNextStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.OnKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ErrorKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ResumeKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.NextKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenResumeStatement() As InternalSyntax.ResumeStatementSyntax
            return InternalSyntax.SyntaxFactory.ResumeStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ResumeKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenResumeLabelStatement() As InternalSyntax.ResumeStatementSyntax
            return InternalSyntax.SyntaxFactory.ResumeLabelStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ResumeKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenResumeNextStatement() As InternalSyntax.ResumeStatementSyntax
            return InternalSyntax.SyntaxFactory.ResumeNextStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ResumeKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSelectBlock() As InternalSyntax.SelectBlockSyntax
            return InternalSyntax.SyntaxFactory.SelectBlock(GenerateGreenSelectStatement(), Nothing, GenerateGreenEndSelectStatement())
        End Function
 
        Private Shared Function GenerateGreenSelectStatement() As InternalSyntax.SelectStatementSyntax
            return InternalSyntax.SyntaxFactory.SelectStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.SelectKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseBlock() As InternalSyntax.CaseBlockSyntax
            return InternalSyntax.SyntaxFactory.CaseBlock(GenerateGreenCaseStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenCaseElseBlock() As InternalSyntax.CaseBlockSyntax
            return InternalSyntax.SyntaxFactory.CaseElseBlock(GenerateGreenCaseStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenCaseStatement() As InternalSyntax.CaseStatementSyntax
            return InternalSyntax.SyntaxFactory.CaseStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.CaseKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenCaseElseStatement() As InternalSyntax.CaseStatementSyntax
            return InternalSyntax.SyntaxFactory.CaseElseStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.CaseKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenElseCaseClause() As InternalSyntax.ElseCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.ElseCaseClause(new InternalSyntax.KeywordSyntax(SyntaxKind.ElseKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenSimpleCaseClause() As InternalSyntax.SimpleCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.SimpleCaseClause(GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenRangeCaseClause() As InternalSyntax.RangeCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.RangeCaseClause(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.ToKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseEqualsClause() As InternalSyntax.RelationalCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.CaseEqualsClause(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseNotEqualsClause() As InternalSyntax.RelationalCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.CaseNotEqualsClause(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanGreaterThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseLessThanClause() As InternalSyntax.RelationalCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.CaseLessThanClause(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseLessThanOrEqualClause() As InternalSyntax.RelationalCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.CaseLessThanOrEqualClause(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseGreaterThanOrEqualClause() As InternalSyntax.RelationalCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.CaseGreaterThanOrEqualClause(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenCaseGreaterThanClause() As InternalSyntax.RelationalCaseClauseSyntax
            return InternalSyntax.SyntaxFactory.CaseGreaterThanClause(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSyncLockStatement() As InternalSyntax.SyncLockStatementSyntax
            return InternalSyntax.SyntaxFactory.SyncLockStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.SyncLockKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSimpleDoLoopBlock() As InternalSyntax.DoLoopBlockSyntax
            return InternalSyntax.SyntaxFactory.SimpleDoLoopBlock(GenerateGreenSimpleDoStatement(), Nothing, GenerateGreenSimpleLoopStatement())
        End Function
 
        Private Shared Function GenerateGreenDoWhileLoopBlock() As InternalSyntax.DoLoopBlockSyntax
            return InternalSyntax.SyntaxFactory.DoWhileLoopBlock(GenerateGreenDoWhileStatement(), Nothing, GenerateGreenSimpleLoopStatement())
        End Function
 
        Private Shared Function GenerateGreenDoUntilLoopBlock() As InternalSyntax.DoLoopBlockSyntax
            return InternalSyntax.SyntaxFactory.DoUntilLoopBlock(GenerateGreenDoUntilStatement(), Nothing, GenerateGreenSimpleLoopStatement())
        End Function
 
        Private Shared Function GenerateGreenDoLoopWhileBlock() As InternalSyntax.DoLoopBlockSyntax
            return InternalSyntax.SyntaxFactory.DoLoopWhileBlock(GenerateGreenSimpleDoStatement(), Nothing, GenerateGreenLoopWhileStatement())
        End Function
 
        Private Shared Function GenerateGreenDoLoopUntilBlock() As InternalSyntax.DoLoopBlockSyntax
            return InternalSyntax.SyntaxFactory.DoLoopUntilBlock(GenerateGreenSimpleDoStatement(), Nothing, GenerateGreenLoopUntilStatement())
        End Function
 
        Private Shared Function GenerateGreenSimpleDoStatement() As InternalSyntax.DoStatementSyntax
            return InternalSyntax.SyntaxFactory.SimpleDoStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.DoKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenDoWhileStatement() As InternalSyntax.DoStatementSyntax
            return InternalSyntax.SyntaxFactory.DoWhileStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.DoKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenDoUntilStatement() As InternalSyntax.DoStatementSyntax
            return InternalSyntax.SyntaxFactory.DoUntilStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.DoKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSimpleLoopStatement() As InternalSyntax.LoopStatementSyntax
            return InternalSyntax.SyntaxFactory.SimpleLoopStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.LoopKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenLoopWhileStatement() As InternalSyntax.LoopStatementSyntax
            return InternalSyntax.SyntaxFactory.LoopWhileStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.LoopKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenLoopUntilStatement() As InternalSyntax.LoopStatementSyntax
            return InternalSyntax.SyntaxFactory.LoopUntilStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.LoopKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenWhileClause() As InternalSyntax.WhileOrUntilClauseSyntax
            return InternalSyntax.SyntaxFactory.WhileClause(new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenUntilClause() As InternalSyntax.WhileOrUntilClauseSyntax
            return InternalSyntax.SyntaxFactory.UntilClause(new InternalSyntax.KeywordSyntax(SyntaxKind.UntilKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenWhileStatement() As InternalSyntax.WhileStatementSyntax
            return InternalSyntax.SyntaxFactory.WhileStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenForBlock() As InternalSyntax.ForBlockSyntax
            return InternalSyntax.SyntaxFactory.ForBlock(GenerateGreenForStatement(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenForEachBlock() As InternalSyntax.ForEachBlockSyntax
            return InternalSyntax.SyntaxFactory.ForEachBlock(GenerateGreenForEachStatement(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenForStatement() As InternalSyntax.ForStatementSyntax
            return InternalSyntax.SyntaxFactory.ForStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ForKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.ToKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenForStepClause() As InternalSyntax.ForStepClauseSyntax
            return InternalSyntax.SyntaxFactory.ForStepClause(new InternalSyntax.KeywordSyntax(SyntaxKind.StepKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenForEachStatement() As InternalSyntax.ForEachStatementSyntax
            return InternalSyntax.SyntaxFactory.ForEachStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ForKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.EachKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.InKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenNextStatement() As InternalSyntax.NextStatementSyntax
            return InternalSyntax.SyntaxFactory.NextStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.NextKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenUsingStatement() As InternalSyntax.UsingStatementSyntax
            return InternalSyntax.SyntaxFactory.UsingStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.UsingKeyword, String.Empty, Nothing, Nothing), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenThrowStatement() As InternalSyntax.ThrowStatementSyntax
            return InternalSyntax.SyntaxFactory.ThrowStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ThrowKeyword, String.Empty, Nothing, Nothing), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSimpleAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.SimpleAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenMidAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.MidAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenAddAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.AddAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.PlusEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSubtractAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.SubtractAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.MinusEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenMultiplyAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.MultiplyAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.AsteriskEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenDivideAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.DivideAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.SlashEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenIntegerDivideAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.IntegerDivideAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.BackslashEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenExponentiateAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.ExponentiateAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CaretEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenLeftShiftAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.LeftShiftAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanLessThanEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenRightShiftAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.RightShiftAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanGreaterThanEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenConcatenateAssignmentStatement() As InternalSyntax.AssignmentStatementSyntax
            return InternalSyntax.SyntaxFactory.ConcatenateAssignmentStatement(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.AmpersandEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenMidExpression() As InternalSyntax.MidExpressionSyntax
            return InternalSyntax.SyntaxFactory.MidExpression(GenerateGreenIdentifierToken(), GenerateGreenArgumentList())
        End Function
 
        Private Shared Function GenerateGreenCallStatement() As InternalSyntax.CallStatementSyntax
            return InternalSyntax.SyntaxFactory.CallStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.CallKeyword, String.Empty, Nothing, Nothing), GenerateGreenInvocationExpression())
        End Function
 
        Private Shared Function GenerateGreenAddHandlerStatement() As InternalSyntax.AddRemoveHandlerStatementSyntax
            return InternalSyntax.SyntaxFactory.AddHandlerStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.AddHandlerKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenRemoveHandlerStatement() As InternalSyntax.AddRemoveHandlerStatementSyntax
            return InternalSyntax.SyntaxFactory.RemoveHandlerStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.RemoveHandlerKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenRaiseEventStatement() As InternalSyntax.RaiseEventStatementSyntax
            return InternalSyntax.SyntaxFactory.RaiseEventStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.RaiseEventKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenWithStatement() As InternalSyntax.WithStatementSyntax
            return InternalSyntax.SyntaxFactory.WithStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.WithKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenReDimStatement() As InternalSyntax.ReDimStatementSyntax
            return InternalSyntax.SyntaxFactory.ReDimStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ReDimKeyword, String.Empty, Nothing, Nothing), Nothing, New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenReDimPreserveStatement() As InternalSyntax.ReDimStatementSyntax
            return InternalSyntax.SyntaxFactory.ReDimPreserveStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.ReDimKeyword, String.Empty, Nothing, Nothing), Nothing, New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenRedimClause() As InternalSyntax.RedimClauseSyntax
            return InternalSyntax.SyntaxFactory.RedimClause(GenerateGreenKeywordEventContainer(), GenerateGreenArgumentList())
        End Function
 
        Private Shared Function GenerateGreenEraseStatement() As InternalSyntax.EraseStatementSyntax
            return InternalSyntax.SyntaxFactory.EraseStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.EraseKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenCharacterLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.CharacterLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenTrueLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.TrueLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenFalseLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.FalseLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenNumericLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.NumericLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenDateLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.DateLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenStringLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.StringLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenNothingLiteralExpression() As InternalSyntax.LiteralExpressionSyntax
            return InternalSyntax.SyntaxFactory.NothingLiteralExpression(GenerateGreenIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenParenthesizedExpression() As InternalSyntax.ParenthesizedExpressionSyntax
            return InternalSyntax.SyntaxFactory.ParenthesizedExpression(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTupleExpression() As InternalSyntax.TupleExpressionSyntax
            return InternalSyntax.SyntaxFactory.TupleExpression(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTupleType() As InternalSyntax.TupleTypeSyntax
            return InternalSyntax.SyntaxFactory.TupleType(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTypedTupleElement() As InternalSyntax.TypedTupleElementSyntax
            return InternalSyntax.SyntaxFactory.TypedTupleElement(GenerateGreenTupleType())
        End Function
 
        Private Shared Function GenerateGreenNamedTupleElement() As InternalSyntax.NamedTupleElementSyntax
            return InternalSyntax.SyntaxFactory.NamedTupleElement(GenerateGreenIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenMeExpression() As InternalSyntax.MeExpressionSyntax
            return InternalSyntax.SyntaxFactory.MeExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.MeKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenMyBaseExpression() As InternalSyntax.MyBaseExpressionSyntax
            return InternalSyntax.SyntaxFactory.MyBaseExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.MyBaseKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenMyClassExpression() As InternalSyntax.MyClassExpressionSyntax
            return InternalSyntax.SyntaxFactory.MyClassExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.MyClassKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenGetTypeExpression() As InternalSyntax.GetTypeExpressionSyntax
            return InternalSyntax.SyntaxFactory.GetTypeExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.GetTypeKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenTupleType(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTypeOfIsExpression() As InternalSyntax.TypeOfExpressionSyntax
            return InternalSyntax.SyntaxFactory.TypeOfIsExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.TypeOfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.IsKeyword, String.Empty, Nothing, Nothing), GenerateGreenTupleType())
        End Function
 
        Private Shared Function GenerateGreenTypeOfIsNotExpression() As InternalSyntax.TypeOfExpressionSyntax
            return InternalSyntax.SyntaxFactory.TypeOfIsNotExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.TypeOfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.IsNotKeyword, String.Empty, Nothing, Nothing), GenerateGreenTupleType())
        End Function
 
        Private Shared Function GenerateGreenGetXmlNamespaceExpression() As InternalSyntax.GetXmlNamespaceExpressionSyntax
            return InternalSyntax.SyntaxFactory.GetXmlNamespaceExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.GetXmlNamespaceKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenSimpleMemberAccessExpression() As InternalSyntax.MemberAccessExpressionSyntax
            return InternalSyntax.SyntaxFactory.SimpleMemberAccessExpression(CType(Nothing, InternalSyntax.ExpressionSyntax), new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenDictionaryAccessExpression() As InternalSyntax.MemberAccessExpressionSyntax
            return InternalSyntax.SyntaxFactory.DictionaryAccessExpression(CType(Nothing, InternalSyntax.ExpressionSyntax), new InternalSyntax.PunctuationSyntax(SyntaxKind.ExclamationToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenXmlElementAccessExpression() As InternalSyntax.XmlMemberAccessExpressionSyntax
            return InternalSyntax.SyntaxFactory.XmlElementAccessExpression(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), Nothing, Nothing, GenerateGreenXmlName())
        End Function
 
        Private Shared Function GenerateGreenXmlDescendantAccessExpression() As InternalSyntax.XmlMemberAccessExpressionSyntax
            return InternalSyntax.SyntaxFactory.XmlDescendantAccessExpression(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), Nothing, Nothing, GenerateGreenXmlName())
        End Function
 
        Private Shared Function GenerateGreenXmlAttributeAccessExpression() As InternalSyntax.XmlMemberAccessExpressionSyntax
            return InternalSyntax.SyntaxFactory.XmlAttributeAccessExpression(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), Nothing, Nothing, GenerateGreenXmlName())
        End Function
 
        Private Shared Function GenerateGreenInvocationExpression() As InternalSyntax.InvocationExpressionSyntax
            return InternalSyntax.SyntaxFactory.InvocationExpression(Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenObjectCreationExpression() As InternalSyntax.ObjectCreationExpressionSyntax
            return InternalSyntax.SyntaxFactory.ObjectCreationExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenPredefinedType(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenAnonymousObjectCreationExpression() As InternalSyntax.AnonymousObjectCreationExpressionSyntax
            return InternalSyntax.SyntaxFactory.AnonymousObjectCreationExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenObjectMemberInitializer())
        End Function
 
        Private Shared Function GenerateGreenArrayCreationExpression() As InternalSyntax.ArrayCreationExpressionSyntax
            return InternalSyntax.SyntaxFactory.ArrayCreationExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.NewKeyword, String.Empty, Nothing, Nothing), Nothing, GenerateGreenPredefinedType(), Nothing, Nothing, GenerateGreenCollectionInitializer())
        End Function
 
        Private Shared Function GenerateGreenCollectionInitializer() As InternalSyntax.CollectionInitializerSyntax
            return InternalSyntax.SyntaxFactory.CollectionInitializer(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenBraceToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseBraceToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenCTypeExpression() As InternalSyntax.CTypeExpressionSyntax
            return InternalSyntax.SyntaxFactory.CTypeExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.CTypeKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenTupleType(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenDirectCastExpression() As InternalSyntax.DirectCastExpressionSyntax
            return InternalSyntax.SyntaxFactory.DirectCastExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.DirectCastKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenTupleType(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTryCastExpression() As InternalSyntax.TryCastExpressionSyntax
            return InternalSyntax.SyntaxFactory.TryCastExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.TryCastKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenTupleType(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenPredefinedCastExpression() As InternalSyntax.PredefinedCastExpressionSyntax
            return InternalSyntax.SyntaxFactory.PredefinedCastExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.CObjKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenAddExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.AddExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.PlusToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSubtractExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.SubtractExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.MinusToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenMultiplyExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.MultiplyExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.AsteriskToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenDivideExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.DivideExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.SlashToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenIntegerDivideExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.IntegerDivideExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.BackslashToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenExponentiateExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.ExponentiateExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CaretToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenLeftShiftExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.LeftShiftExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanLessThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenRightShiftExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.RightShiftExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanGreaterThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenConcatenateExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.ConcatenateExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.AmpersandToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenModuloExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.ModuloExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.ModKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenEqualsExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.EqualsExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenNotEqualsExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.NotEqualsExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanGreaterThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenLessThanExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.LessThanExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenLessThanOrEqualExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.LessThanOrEqualExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenGreaterThanOrEqualExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.GreaterThanOrEqualExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenGreaterThanExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.GreaterThanExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenIsExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.IsExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.IsKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenIsNotExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.IsNotExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.IsNotKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenLikeExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.LikeExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.LikeKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenOrExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.OrExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.OrKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenExclusiveOrExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.ExclusiveOrExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.XorKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenAndExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.AndExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.AndKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenOrElseExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.OrElseExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.OrElseKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenAndAlsoExpression() As InternalSyntax.BinaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.AndAlsoExpression(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.AndAlsoKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenUnaryPlusExpression() As InternalSyntax.UnaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.UnaryPlusExpression(new InternalSyntax.PunctuationSyntax(SyntaxKind.PlusToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenUnaryMinusExpression() As InternalSyntax.UnaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.UnaryMinusExpression(new InternalSyntax.PunctuationSyntax(SyntaxKind.MinusToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenNotExpression() As InternalSyntax.UnaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.NotExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.NotKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenAddressOfExpression() As InternalSyntax.UnaryExpressionSyntax
            return InternalSyntax.SyntaxFactory.AddressOfExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.AddressOfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenBinaryConditionalExpression() As InternalSyntax.BinaryConditionalExpressionSyntax
            return InternalSyntax.SyntaxFactory.BinaryConditionalExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTernaryConditionalExpression() As InternalSyntax.TernaryConditionalExpressionSyntax
            return InternalSyntax.SyntaxFactory.TernaryConditionalExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenSingleLineFunctionLambdaExpression() As InternalSyntax.SingleLineLambdaExpressionSyntax
            return InternalSyntax.SyntaxFactory.SingleLineFunctionLambdaExpression(GenerateGreenSubLambdaHeader(), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSingleLineSubLambdaExpression() As InternalSyntax.SingleLineLambdaExpressionSyntax
            return InternalSyntax.SyntaxFactory.SingleLineSubLambdaExpression(GenerateGreenSubLambdaHeader(), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenMultiLineFunctionLambdaExpression() As InternalSyntax.MultiLineLambdaExpressionSyntax
            return InternalSyntax.SyntaxFactory.MultiLineFunctionLambdaExpression(GenerateGreenSubLambdaHeader(), Nothing, GenerateGreenEndSubStatement())
        End Function
 
        Private Shared Function GenerateGreenMultiLineSubLambdaExpression() As InternalSyntax.MultiLineLambdaExpressionSyntax
            return InternalSyntax.SyntaxFactory.MultiLineSubLambdaExpression(GenerateGreenSubLambdaHeader(), Nothing, GenerateGreenEndSubStatement())
        End Function
 
        Private Shared Function GenerateGreenSubLambdaHeader() As InternalSyntax.LambdaHeaderSyntax
            return InternalSyntax.SyntaxFactory.SubLambdaHeader(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.SubKeyword, String.Empty, Nothing, Nothing), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenFunctionLambdaHeader() As InternalSyntax.LambdaHeaderSyntax
            return InternalSyntax.SyntaxFactory.FunctionLambdaHeader(Nothing, Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.FunctionKeyword, String.Empty, Nothing, Nothing), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenArgumentList() As InternalSyntax.ArgumentListSyntax
            return InternalSyntax.SyntaxFactory.ArgumentList(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenOmittedArgument() As InternalSyntax.OmittedArgumentSyntax
            return InternalSyntax.SyntaxFactory.OmittedArgument(new InternalSyntax.PunctuationSyntax(SyntaxKind.EmptyToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenSimpleArgument() As InternalSyntax.SimpleArgumentSyntax
            return InternalSyntax.SyntaxFactory.SimpleArgument(Nothing, GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenNameColonEquals() As InternalSyntax.NameColonEqualsSyntax
            return InternalSyntax.SyntaxFactory.NameColonEquals(GenerateGreenIdentifierName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.ColonEqualsToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenRangeArgument() As InternalSyntax.RangeArgumentSyntax
            return InternalSyntax.SyntaxFactory.RangeArgument(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.ToKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenQueryExpression() As InternalSyntax.QueryExpressionSyntax
            return InternalSyntax.SyntaxFactory.QueryExpression(GenerateGreenFromClause())
        End Function
 
        Private Shared Function GenerateGreenCollectionRangeVariable() As InternalSyntax.CollectionRangeVariableSyntax
            return InternalSyntax.SyntaxFactory.CollectionRangeVariable(GenerateGreenModifiedIdentifier(), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.InKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenExpressionRangeVariable() As InternalSyntax.ExpressionRangeVariableSyntax
            return InternalSyntax.SyntaxFactory.ExpressionRangeVariable(Nothing, GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenAggregationRangeVariable() As InternalSyntax.AggregationRangeVariableSyntax
            return InternalSyntax.SyntaxFactory.AggregationRangeVariable(Nothing, GenerateGreenFunctionAggregation())
        End Function
 
        Private Shared Function GenerateGreenVariableNameEquals() As InternalSyntax.VariableNameEqualsSyntax
            return InternalSyntax.SyntaxFactory.VariableNameEquals(GenerateGreenModifiedIdentifier(), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenFunctionAggregation() As InternalSyntax.FunctionAggregationSyntax
            return InternalSyntax.SyntaxFactory.FunctionAggregation(GenerateGreenIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenGroupAggregation() As InternalSyntax.GroupAggregationSyntax
            return InternalSyntax.SyntaxFactory.GroupAggregation(new InternalSyntax.KeywordSyntax(SyntaxKind.GroupKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenFromClause() As InternalSyntax.FromClauseSyntax
            return InternalSyntax.SyntaxFactory.FromClause(new InternalSyntax.KeywordSyntax(SyntaxKind.FromKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenLetClause() As InternalSyntax.LetClauseSyntax
            return InternalSyntax.SyntaxFactory.LetClause(new InternalSyntax.KeywordSyntax(SyntaxKind.LetKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenAggregateClause() As InternalSyntax.AggregateClauseSyntax
            return InternalSyntax.SyntaxFactory.AggregateClause(new InternalSyntax.KeywordSyntax(SyntaxKind.AggregateKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.IntoKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenDistinctClause() As InternalSyntax.DistinctClauseSyntax
            return InternalSyntax.SyntaxFactory.DistinctClause(new InternalSyntax.KeywordSyntax(SyntaxKind.DistinctKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenWhereClause() As InternalSyntax.WhereClauseSyntax
            return InternalSyntax.SyntaxFactory.WhereClause(new InternalSyntax.KeywordSyntax(SyntaxKind.WhereKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSkipWhileClause() As InternalSyntax.PartitionWhileClauseSyntax
            return InternalSyntax.SyntaxFactory.SkipWhileClause(new InternalSyntax.KeywordSyntax(SyntaxKind.SkipKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenTakeWhileClause() As InternalSyntax.PartitionWhileClauseSyntax
            return InternalSyntax.SyntaxFactory.TakeWhileClause(new InternalSyntax.KeywordSyntax(SyntaxKind.TakeKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WhileKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSkipClause() As InternalSyntax.PartitionClauseSyntax
            return InternalSyntax.SyntaxFactory.SkipClause(new InternalSyntax.KeywordSyntax(SyntaxKind.SkipKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenTakeClause() As InternalSyntax.PartitionClauseSyntax
            return InternalSyntax.SyntaxFactory.TakeClause(new InternalSyntax.KeywordSyntax(SyntaxKind.TakeKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenGroupByClause() As InternalSyntax.GroupByClauseSyntax
            return InternalSyntax.SyntaxFactory.GroupByClause(new InternalSyntax.KeywordSyntax(SyntaxKind.GroupKeyword, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.ByKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.KeywordSyntax(SyntaxKind.IntoKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenJoinCondition() As InternalSyntax.JoinConditionSyntax
            return InternalSyntax.SyntaxFactory.JoinCondition(GenerateGreenKeywordEventContainer(), new InternalSyntax.KeywordSyntax(SyntaxKind.EqualsKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenSimpleJoinClause() As InternalSyntax.SimpleJoinClauseSyntax
            return InternalSyntax.SyntaxFactory.SimpleJoinClause(new InternalSyntax.KeywordSyntax(SyntaxKind.JoinKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.OnKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenGroupJoinClause() As InternalSyntax.GroupJoinClauseSyntax
            return InternalSyntax.SyntaxFactory.GroupJoinClause(new InternalSyntax.KeywordSyntax(SyntaxKind.GroupKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.JoinKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.OnKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.KeywordSyntax(SyntaxKind.IntoKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenOrderByClause() As InternalSyntax.OrderByClauseSyntax
            return InternalSyntax.SyntaxFactory.OrderByClause(new InternalSyntax.KeywordSyntax(SyntaxKind.OrderKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ByKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenAscendingOrdering() As InternalSyntax.OrderingSyntax
            return InternalSyntax.SyntaxFactory.AscendingOrdering(GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenDescendingOrdering() As InternalSyntax.OrderingSyntax
            return InternalSyntax.SyntaxFactory.DescendingOrdering(GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenSelectClause() As InternalSyntax.SelectClauseSyntax
            return InternalSyntax.SyntaxFactory.SelectClause(new InternalSyntax.KeywordSyntax(SyntaxKind.SelectKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenXmlDocument() As InternalSyntax.XmlDocumentSyntax
            return InternalSyntax.SyntaxFactory.XmlDocument(GenerateGreenXmlDeclaration(), Nothing, GenerateGreenXmlElement(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenXmlDeclaration() As InternalSyntax.XmlDeclarationSyntax
            return InternalSyntax.SyntaxFactory.XmlDeclaration(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanQuestionToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.XmlKeyword, String.Empty, Nothing, Nothing), GenerateGreenXmlDeclarationOption(), Nothing, Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.QuestionGreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlDeclarationOption() As InternalSyntax.XmlDeclarationOptionSyntax
            return InternalSyntax.SyntaxFactory.XmlDeclarationOption(GenerateGreenXmlNameToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenXmlString())
        End Function
 
        Private Shared Function GenerateGreenXmlElement() As InternalSyntax.XmlElementSyntax
            return InternalSyntax.SyntaxFactory.XmlElement(GenerateGreenXmlElementStartTag(), Nothing, GenerateGreenXmlElementEndTag())
        End Function
 
        Private Shared Function GenerateGreenXmlText() As InternalSyntax.XmlTextSyntax
            return InternalSyntax.SyntaxFactory.XmlText(GenerateGreenXmlTextLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenXmlElementStartTag() As InternalSyntax.XmlElementStartTagSyntax
            return InternalSyntax.SyntaxFactory.XmlElementStartTag(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), GenerateGreenXmlName(), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlElementEndTag() As InternalSyntax.XmlElementEndTagSyntax
            return InternalSyntax.SyntaxFactory.XmlElementEndTag(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanSlashToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlEmptyElement() As InternalSyntax.XmlEmptyElementSyntax
            return InternalSyntax.SyntaxFactory.XmlEmptyElement(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), GenerateGreenXmlName(), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.SlashGreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlAttribute() As InternalSyntax.XmlAttributeSyntax
            return InternalSyntax.SyntaxFactory.XmlAttribute(GenerateGreenXmlName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenXmlString())
        End Function
 
        Private Shared Function GenerateGreenXmlString() As InternalSyntax.XmlStringSyntax
            return InternalSyntax.SyntaxFactory.XmlString(new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlPrefixName() As InternalSyntax.XmlPrefixNameSyntax
            return InternalSyntax.SyntaxFactory.XmlPrefixName(GenerateGreenXmlNameToken())
        End Function
 
        Private Shared Function GenerateGreenXmlName() As InternalSyntax.XmlNameSyntax
            return InternalSyntax.SyntaxFactory.XmlName(Nothing, GenerateGreenXmlNameToken())
        End Function
 
        Private Shared Function GenerateGreenXmlBracketedName() As InternalSyntax.XmlBracketedNameSyntax
            return InternalSyntax.SyntaxFactory.XmlBracketedName(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanToken, String.Empty, Nothing, Nothing), GenerateGreenXmlName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.GreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlPrefix() As InternalSyntax.XmlPrefixSyntax
            return InternalSyntax.SyntaxFactory.XmlPrefix(GenerateGreenXmlNameToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.ColonToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlComment() As InternalSyntax.XmlCommentSyntax
            return InternalSyntax.SyntaxFactory.XmlComment(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanExclamationMinusMinusToken, String.Empty, Nothing, Nothing), GenerateGreenXmlTextLiteralToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.MinusMinusGreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlProcessingInstruction() As InternalSyntax.XmlProcessingInstructionSyntax
            return InternalSyntax.SyntaxFactory.XmlProcessingInstruction(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanQuestionToken, String.Empty, Nothing, Nothing), GenerateGreenXmlNameToken(), GenerateGreenXmlTextLiteralToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.QuestionGreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlCDataSection() As InternalSyntax.XmlCDataSectionSyntax
            return InternalSyntax.SyntaxFactory.XmlCDataSection(new InternalSyntax.PunctuationSyntax(SyntaxKind.BeginCDataToken, String.Empty, Nothing, Nothing), GenerateGreenXmlTextLiteralToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EndCDataToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlEmbeddedExpression() As InternalSyntax.XmlEmbeddedExpressionSyntax
            return InternalSyntax.SyntaxFactory.XmlEmbeddedExpression(new InternalSyntax.PunctuationSyntax(SyntaxKind.LessThanPercentEqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.PercentGreaterThanToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenArrayType() As InternalSyntax.ArrayTypeSyntax
            return InternalSyntax.SyntaxFactory.ArrayType(GenerateGreenPredefinedType(), GenerateGreenArrayRankSpecifier())
        End Function
 
        Private Shared Function GenerateGreenNullableType() As InternalSyntax.NullableTypeSyntax
            return InternalSyntax.SyntaxFactory.NullableType(GenerateGreenPredefinedType(), new InternalSyntax.PunctuationSyntax(SyntaxKind.QuestionToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenPredefinedType() As InternalSyntax.PredefinedTypeSyntax
            return InternalSyntax.SyntaxFactory.PredefinedType(new InternalSyntax.KeywordSyntax(SyntaxKind.ObjectKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenIdentifierName() As InternalSyntax.IdentifierNameSyntax
            return InternalSyntax.SyntaxFactory.IdentifierName(GenerateGreenIdentifierToken())
        End Function
 
        Private Shared Function GenerateGreenGenericName() As InternalSyntax.GenericNameSyntax
            return InternalSyntax.SyntaxFactory.GenericName(GenerateGreenIdentifierToken(), GenerateGreenTypeArgumentList())
        End Function
 
        Private Shared Function GenerateGreenQualifiedName() As InternalSyntax.QualifiedNameSyntax
            return InternalSyntax.SyntaxFactory.QualifiedName(GenerateGreenIdentifierName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName())
        End Function
 
        Private Shared Function GenerateGreenGlobalName() As InternalSyntax.GlobalNameSyntax
            return InternalSyntax.SyntaxFactory.GlobalName(new InternalSyntax.KeywordSyntax(SyntaxKind.GlobalKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenTypeArgumentList() As InternalSyntax.TypeArgumentListSyntax
            return InternalSyntax.SyntaxFactory.TypeArgumentList(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.OfKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenCrefReference() As InternalSyntax.CrefReferenceSyntax
            return InternalSyntax.SyntaxFactory.CrefReference(GenerateGreenTupleType(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenCrefSignature() As InternalSyntax.CrefSignatureSyntax
            return InternalSyntax.SyntaxFactory.CrefSignature(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenCrefSignaturePart() As InternalSyntax.CrefSignaturePartSyntax
            return InternalSyntax.SyntaxFactory.CrefSignaturePart(Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateGreenCrefOperatorReference() As InternalSyntax.CrefOperatorReferenceSyntax
            return InternalSyntax.SyntaxFactory.CrefOperatorReference(new InternalSyntax.KeywordSyntax(SyntaxKind.OperatorKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.CTypeKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenQualifiedCrefOperatorReference() As InternalSyntax.QualifiedCrefOperatorReferenceSyntax
            return InternalSyntax.SyntaxFactory.QualifiedCrefOperatorReference(GenerateGreenIdentifierName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DotToken, String.Empty, Nothing, Nothing), GenerateGreenCrefOperatorReference())
        End Function
 
        Private Shared Function GenerateGreenYieldStatement() As InternalSyntax.YieldStatementSyntax
            return InternalSyntax.SyntaxFactory.YieldStatement(new InternalSyntax.KeywordSyntax(SyntaxKind.YieldKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenAwaitExpression() As InternalSyntax.AwaitExpressionSyntax
            return InternalSyntax.SyntaxFactory.AwaitExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.AwaitKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenXmlNameToken() As InternalSyntax.XmlNameTokenSyntax
            return InternalSyntax.SyntaxFactory.XmlNameToken(String.Empty, SyntaxKind.IdentifierName, InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenXmlTextLiteralToken() As InternalSyntax.XmlTextTokenSyntax
            return InternalSyntax.SyntaxFactory.XmlTextLiteralToken(String.Empty, "Bar", InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenXmlEntityLiteralToken() As InternalSyntax.XmlTextTokenSyntax
            return InternalSyntax.SyntaxFactory.XmlEntityLiteralToken(String.Empty, "Bar", InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenDocumentationCommentLineBreakToken() As InternalSyntax.XmlTextTokenSyntax
            return InternalSyntax.SyntaxFactory.DocumentationCommentLineBreakToken(String.Empty, "Bar", InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenInterpolatedStringTextToken() As InternalSyntax.InterpolatedStringTextTokenSyntax
            return InternalSyntax.SyntaxFactory.InterpolatedStringTextToken(String.Empty, "Bar", InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenDecimalLiteralToken() As InternalSyntax.DecimalLiteralTokenSyntax
            return InternalSyntax.SyntaxFactory.DecimalLiteralToken(String.Empty, TypeCharacter.DecimalLiteral, 42, InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenDateLiteralToken() As InternalSyntax.DateLiteralTokenSyntax
            return InternalSyntax.SyntaxFactory.DateLiteralToken(String.Empty, New DateTime(2008,11,04), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenStringLiteralToken() As InternalSyntax.StringLiteralTokenSyntax
            return InternalSyntax.SyntaxFactory.StringLiteralToken(String.Empty, "Bar", InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenCharacterLiteralToken() As InternalSyntax.CharacterLiteralTokenSyntax
            return InternalSyntax.SyntaxFactory.CharacterLiteralToken(String.Empty, "E"C, InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "), InternalSyntax.SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))
        End Function
 
        Private Shared Function GenerateGreenSkippedTokensTrivia() As InternalSyntax.SkippedTokensTriviaSyntax
            return InternalSyntax.SyntaxFactory.SkippedTokensTrivia(Nothing)
        End Function
 
        Private Shared Function GenerateGreenDocumentationCommentTrivia() As InternalSyntax.DocumentationCommentTriviaSyntax
            return InternalSyntax.SyntaxFactory.DocumentationCommentTrivia(Nothing)
        End Function
 
        Private Shared Function GenerateGreenXmlCrefAttribute() As InternalSyntax.XmlCrefAttributeSyntax
            return InternalSyntax.SyntaxFactory.XmlCrefAttribute(GenerateGreenXmlName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing), GenerateGreenCrefReference(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenXmlNameAttribute() As InternalSyntax.XmlNameAttributeSyntax
            return InternalSyntax.SyntaxFactory.XmlNameAttribute(GenerateGreenXmlName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing), GenerateGreenIdentifierName(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenConditionalAccessExpression() As InternalSyntax.ConditionalAccessExpressionSyntax
            return InternalSyntax.SyntaxFactory.ConditionalAccessExpression(Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.QuestionToken, String.Empty, Nothing, Nothing), GenerateGreenDictionaryAccessExpression())
        End Function
 
        Private Shared Function GenerateGreenNameOfExpression() As InternalSyntax.NameOfExpressionSyntax
            return InternalSyntax.SyntaxFactory.NameOfExpression(new InternalSyntax.KeywordSyntax(SyntaxKind.NameOfKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenInterpolatedStringExpression() As InternalSyntax.InterpolatedStringExpressionSyntax
            return InternalSyntax.SyntaxFactory.InterpolatedStringExpression(new InternalSyntax.PunctuationSyntax(SyntaxKind.DollarSignDoubleQuoteToken, String.Empty, Nothing, Nothing), GenerateGreenInterpolatedStringText(), new InternalSyntax.PunctuationSyntax(SyntaxKind.DoubleQuoteToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenInterpolatedStringText() As InternalSyntax.InterpolatedStringTextSyntax
            return InternalSyntax.SyntaxFactory.InterpolatedStringText(GenerateGreenInterpolatedStringTextToken())
        End Function
 
        Private Shared Function GenerateGreenInterpolation() As InternalSyntax.InterpolationSyntax
            return InternalSyntax.SyntaxFactory.Interpolation(new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenBraceToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), Nothing, Nothing, new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseBraceToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenInterpolationAlignmentClause() As InternalSyntax.InterpolationAlignmentClauseSyntax
            return InternalSyntax.SyntaxFactory.InterpolationAlignmentClause(new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenInterpolationFormatClause() As InternalSyntax.InterpolationFormatClauseSyntax
            return InternalSyntax.SyntaxFactory.InterpolationFormatClause(new InternalSyntax.PunctuationSyntax(SyntaxKind.ColonToken, String.Empty, Nothing, Nothing), GenerateGreenInterpolatedStringTextToken())
        End Function
 
        Private Shared Function GenerateGreenWhitespaceTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.WhitespaceTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenEndOfLineTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.EndOfLineTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenColonTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.ColonTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenCommentTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.CommentTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenConflictMarkerTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.ConflictMarkerTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenLineContinuationTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.LineContinuationTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenDocumentationCommentExteriorTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.DocumentationCommentExteriorTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenDisabledTextTrivia() As InternalSyntax.SyntaxTrivia
            return InternalSyntax.SyntaxFactory.DisabledTextTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateGreenConstDirectiveTrivia() As InternalSyntax.ConstDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.ConstDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ConstKeyword, String.Empty, Nothing, Nothing), GenerateGreenIdentifierToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.EqualsToken, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateGreenIfDirectiveTrivia() As InternalSyntax.IfDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.IfDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenElseIfDirectiveTrivia() As InternalSyntax.IfDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.ElseIfDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), Nothing, new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing), GenerateGreenKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateGreenElseDirectiveTrivia() As InternalSyntax.ElseDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.ElseDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ElseKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEndIfDirectiveTrivia() As InternalSyntax.EndIfDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.EndIfDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.IfKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenRegionDirectiveTrivia() As InternalSyntax.RegionDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.RegionDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.RegionKeyword, String.Empty, Nothing, Nothing), GenerateGreenStringLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenEndRegionDirectiveTrivia() As InternalSyntax.EndRegionDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.EndRegionDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.EndKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.RegionKeyword, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenExternalChecksumDirectiveTrivia() As InternalSyntax.ExternalChecksumDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.ExternalChecksumDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ExternalChecksumKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.PunctuationSyntax(SyntaxKind.OpenParenToken, String.Empty, Nothing, Nothing), GenerateGreenStringLiteralToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenStringLiteralToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CommaToken, String.Empty, Nothing, Nothing), GenerateGreenStringLiteralToken(), new InternalSyntax.PunctuationSyntax(SyntaxKind.CloseParenToken, String.Empty, Nothing, Nothing))
        End Function
 
        Private Shared Function GenerateGreenEnableWarningDirectiveTrivia() As InternalSyntax.EnableWarningDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.EnableWarningDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.EnableKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WarningKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenDisableWarningDirectiveTrivia() As InternalSyntax.DisableWarningDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.DisableWarningDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.DisableKeyword, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.WarningKeyword, String.Empty, Nothing, Nothing), New Global.Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(of GreenNode)())
        End Function
 
        Private Shared Function GenerateGreenReferenceDirectiveTrivia() As InternalSyntax.ReferenceDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.ReferenceDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing), new InternalSyntax.KeywordSyntax(SyntaxKind.ReferenceKeyword, String.Empty, Nothing, Nothing), GenerateGreenStringLiteralToken())
        End Function
 
        Private Shared Function GenerateGreenBadDirectiveTrivia() As InternalSyntax.BadDirectiveTriviaSyntax
            return InternalSyntax.SyntaxFactory.BadDirectiveTrivia(new InternalSyntax.PunctuationSyntax(SyntaxKind.HashToken, String.Empty, Nothing, Nothing))
        End Function
 
#end region
 
#region "Green Factory Tests"
        <Fact>
        Public Sub TestGreenEmptyStatement()
            dim objectUnderTest = GenerateGreenEmptyStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndIfStatement()
            dim objectUnderTest = GenerateGreenEndIfStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndUsingStatement()
            dim objectUnderTest = GenerateGreenEndUsingStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndWithStatement()
            dim objectUnderTest = GenerateGreenEndWithStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSelectStatement()
            dim objectUnderTest = GenerateGreenEndSelectStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndStructureStatement()
            dim objectUnderTest = GenerateGreenEndStructureStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndEnumStatement()
            dim objectUnderTest = GenerateGreenEndEnumStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndInterfaceStatement()
            dim objectUnderTest = GenerateGreenEndInterfaceStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndClassStatement()
            dim objectUnderTest = GenerateGreenEndClassStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndModuleStatement()
            dim objectUnderTest = GenerateGreenEndModuleStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndNamespaceStatement()
            dim objectUnderTest = GenerateGreenEndNamespaceStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSubStatement()
            dim objectUnderTest = GenerateGreenEndSubStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndFunctionStatement()
            dim objectUnderTest = GenerateGreenEndFunctionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndGetStatement()
            dim objectUnderTest = GenerateGreenEndGetStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSetStatement()
            dim objectUnderTest = GenerateGreenEndSetStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndPropertyStatement()
            dim objectUnderTest = GenerateGreenEndPropertyStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndOperatorStatement()
            dim objectUnderTest = GenerateGreenEndOperatorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndEventStatement()
            dim objectUnderTest = GenerateGreenEndEventStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndAddHandlerStatement()
            dim objectUnderTest = GenerateGreenEndAddHandlerStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRemoveHandlerStatement()
            dim objectUnderTest = GenerateGreenEndRemoveHandlerStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRaiseEventStatement()
            dim objectUnderTest = GenerateGreenEndRaiseEventStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndWhileStatement()
            dim objectUnderTest = GenerateGreenEndWhileStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndTryStatement()
            dim objectUnderTest = GenerateGreenEndTryStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSyncLockStatement()
            dim objectUnderTest = GenerateGreenEndSyncLockStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCompilationUnit()
            dim objectUnderTest = GenerateGreenCompilationUnit()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOptionStatement()
            dim objectUnderTest = GenerateGreenOptionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenImportsStatement()
            dim objectUnderTest = GenerateGreenImportsStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleImportsClause()
            dim objectUnderTest = GenerateGreenSimpleImportsClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenImportAliasClause()
            dim objectUnderTest = GenerateGreenImportAliasClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNamespaceImportsClause()
            dim objectUnderTest = GenerateGreenXmlNamespaceImportsClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamespaceBlock()
            dim objectUnderTest = GenerateGreenNamespaceBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamespaceStatement()
            dim objectUnderTest = GenerateGreenNamespaceStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuleBlock()
            dim objectUnderTest = GenerateGreenModuleBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureBlock()
            dim objectUnderTest = GenerateGreenStructureBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterfaceBlock()
            dim objectUnderTest = GenerateGreenInterfaceBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassBlock()
            dim objectUnderTest = GenerateGreenClassBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumBlock()
            dim objectUnderTest = GenerateGreenEnumBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInheritsStatement()
            dim objectUnderTest = GenerateGreenInheritsStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenImplementsStatement()
            dim objectUnderTest = GenerateGreenImplementsStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuleStatement()
            dim objectUnderTest = GenerateGreenModuleStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureStatement()
            dim objectUnderTest = GenerateGreenStructureStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterfaceStatement()
            dim objectUnderTest = GenerateGreenInterfaceStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassStatement()
            dim objectUnderTest = GenerateGreenClassStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumStatement()
            dim objectUnderTest = GenerateGreenEnumStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterList()
            dim objectUnderTest = GenerateGreenTypeParameterList()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameter()
            dim objectUnderTest = GenerateGreenTypeParameter()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterSingleConstraintClause()
            dim objectUnderTest = GenerateGreenTypeParameterSingleConstraintClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterMultipleConstraintClause()
            dim objectUnderTest = GenerateGreenTypeParameterMultipleConstraintClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNewConstraint()
            dim objectUnderTest = GenerateGreenNewConstraint()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassConstraint()
            dim objectUnderTest = GenerateGreenClassConstraint()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureConstraint()
            dim objectUnderTest = GenerateGreenStructureConstraint()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeConstraint()
            dim objectUnderTest = GenerateGreenTypeConstraint()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumMemberDeclaration()
            dim objectUnderTest = GenerateGreenEnumMemberDeclaration()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubBlock()
            dim objectUnderTest = GenerateGreenSubBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionBlock()
            dim objectUnderTest = GenerateGreenFunctionBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenConstructorBlock()
            dim objectUnderTest = GenerateGreenConstructorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOperatorBlock()
            dim objectUnderTest = GenerateGreenOperatorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetAccessorBlock()
            dim objectUnderTest = GenerateGreenGetAccessorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSetAccessorBlock()
            dim objectUnderTest = GenerateGreenSetAccessorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerAccessorBlock()
            dim objectUnderTest = GenerateGreenAddHandlerAccessorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerAccessorBlock()
            dim objectUnderTest = GenerateGreenRemoveHandlerAccessorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventAccessorBlock()
            dim objectUnderTest = GenerateGreenRaiseEventAccessorBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenPropertyBlock()
            dim objectUnderTest = GenerateGreenPropertyBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEventBlock()
            dim objectUnderTest = GenerateGreenEventBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenParameterList()
            dim objectUnderTest = GenerateGreenParameterList()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubStatement()
            dim objectUnderTest = GenerateGreenSubStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionStatement()
            dim objectUnderTest = GenerateGreenFunctionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubNewStatement()
            dim objectUnderTest = GenerateGreenSubNewStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDeclareSubStatement()
            dim objectUnderTest = GenerateGreenDeclareSubStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDeclareFunctionStatement()
            dim objectUnderTest = GenerateGreenDeclareFunctionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDelegateSubStatement()
            dim objectUnderTest = GenerateGreenDelegateSubStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDelegateFunctionStatement()
            dim objectUnderTest = GenerateGreenDelegateFunctionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEventStatement()
            dim objectUnderTest = GenerateGreenEventStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOperatorStatement()
            dim objectUnderTest = GenerateGreenOperatorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenPropertyStatement()
            dim objectUnderTest = GenerateGreenPropertyStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetAccessorStatement()
            dim objectUnderTest = GenerateGreenGetAccessorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSetAccessorStatement()
            dim objectUnderTest = GenerateGreenSetAccessorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerAccessorStatement()
            dim objectUnderTest = GenerateGreenAddHandlerAccessorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerAccessorStatement()
            dim objectUnderTest = GenerateGreenRemoveHandlerAccessorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventAccessorStatement()
            dim objectUnderTest = GenerateGreenRaiseEventAccessorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenImplementsClause()
            dim objectUnderTest = GenerateGreenImplementsClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenHandlesClause()
            dim objectUnderTest = GenerateGreenHandlesClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenKeywordEventContainer()
            dim objectUnderTest = GenerateGreenKeywordEventContainer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithEventsEventContainer()
            dim objectUnderTest = GenerateGreenWithEventsEventContainer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithEventsPropertyEventContainer()
            dim objectUnderTest = GenerateGreenWithEventsPropertyEventContainer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenHandlesClauseItem()
            dim objectUnderTest = GenerateGreenHandlesClauseItem()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIncompleteMember()
            dim objectUnderTest = GenerateGreenIncompleteMember()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFieldDeclaration()
            dim objectUnderTest = GenerateGreenFieldDeclaration()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenVariableDeclarator()
            dim objectUnderTest = GenerateGreenVariableDeclarator()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleAsClause()
            dim objectUnderTest = GenerateGreenSimpleAsClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAsNewClause()
            dim objectUnderTest = GenerateGreenAsNewClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectMemberInitializer()
            dim objectUnderTest = GenerateGreenObjectMemberInitializer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectCollectionInitializer()
            dim objectUnderTest = GenerateGreenObjectCollectionInitializer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInferredFieldInitializer()
            dim objectUnderTest = GenerateGreenInferredFieldInitializer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamedFieldInitializer()
            dim objectUnderTest = GenerateGreenNamedFieldInitializer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEqualsValue()
            dim objectUnderTest = GenerateGreenEqualsValue()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenParameter()
            dim objectUnderTest = GenerateGreenParameter()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenModifiedIdentifier()
            dim objectUnderTest = GenerateGreenModifiedIdentifier()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayRankSpecifier()
            dim objectUnderTest = GenerateGreenArrayRankSpecifier()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeList()
            dim objectUnderTest = GenerateGreenAttributeList()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttribute()
            dim objectUnderTest = GenerateGreenAttribute()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeTarget()
            dim objectUnderTest = GenerateGreenAttributeTarget()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributesStatement()
            dim objectUnderTest = GenerateGreenAttributesStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExpressionStatement()
            dim objectUnderTest = GenerateGreenExpressionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenPrintStatement()
            dim objectUnderTest = GenerateGreenPrintStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileBlock()
            dim objectUnderTest = GenerateGreenWhileBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenUsingBlock()
            dim objectUnderTest = GenerateGreenUsingBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSyncLockBlock()
            dim objectUnderTest = GenerateGreenSyncLockBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithBlock()
            dim objectUnderTest = GenerateGreenWithBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLocalDeclarationStatement()
            dim objectUnderTest = GenerateGreenLocalDeclarationStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLabelStatement()
            dim objectUnderTest = GenerateGreenLabelStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGoToStatement()
            dim objectUnderTest = GenerateGreenGoToStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIdentifierLabel()
            dim objectUnderTest = GenerateGreenIdentifierLabel()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNumericLabel()
            dim objectUnderTest = GenerateGreenNumericLabel()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNextLabel()
            dim objectUnderTest = GenerateGreenNextLabel()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenStopStatement()
            dim objectUnderTest = GenerateGreenStopStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndStatement()
            dim objectUnderTest = GenerateGreenEndStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitDoStatement()
            dim objectUnderTest = GenerateGreenExitDoStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitForStatement()
            dim objectUnderTest = GenerateGreenExitForStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitSubStatement()
            dim objectUnderTest = GenerateGreenExitSubStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitFunctionStatement()
            dim objectUnderTest = GenerateGreenExitFunctionStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitOperatorStatement()
            dim objectUnderTest = GenerateGreenExitOperatorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitPropertyStatement()
            dim objectUnderTest = GenerateGreenExitPropertyStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitTryStatement()
            dim objectUnderTest = GenerateGreenExitTryStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitSelectStatement()
            dim objectUnderTest = GenerateGreenExitSelectStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitWhileStatement()
            dim objectUnderTest = GenerateGreenExitWhileStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueWhileStatement()
            dim objectUnderTest = GenerateGreenContinueWhileStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueDoStatement()
            dim objectUnderTest = GenerateGreenContinueDoStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueForStatement()
            dim objectUnderTest = GenerateGreenContinueForStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenReturnStatement()
            dim objectUnderTest = GenerateGreenReturnStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineIfStatement()
            dim objectUnderTest = GenerateGreenSingleLineIfStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineElseClause()
            dim objectUnderTest = GenerateGreenSingleLineElseClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineIfBlock()
            dim objectUnderTest = GenerateGreenMultiLineIfBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIfStatement()
            dim objectUnderTest = GenerateGreenIfStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfBlock()
            dim objectUnderTest = GenerateGreenElseIfBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfStatement()
            dim objectUnderTest = GenerateGreenElseIfStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseBlock()
            dim objectUnderTest = GenerateGreenElseBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseStatement()
            dim objectUnderTest = GenerateGreenElseStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryBlock()
            dim objectUnderTest = GenerateGreenTryBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryStatement()
            dim objectUnderTest = GenerateGreenTryStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchBlock()
            dim objectUnderTest = GenerateGreenCatchBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchStatement()
            dim objectUnderTest = GenerateGreenCatchStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchFilterClause()
            dim objectUnderTest = GenerateGreenCatchFilterClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFinallyBlock()
            dim objectUnderTest = GenerateGreenFinallyBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFinallyStatement()
            dim objectUnderTest = GenerateGreenFinallyStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenErrorStatement()
            dim objectUnderTest = GenerateGreenErrorStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToZeroStatement()
            dim objectUnderTest = GenerateGreenOnErrorGoToZeroStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToMinusOneStatement()
            dim objectUnderTest = GenerateGreenOnErrorGoToMinusOneStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToLabelStatement()
            dim objectUnderTest = GenerateGreenOnErrorGoToLabelStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorResumeNextStatement()
            dim objectUnderTest = GenerateGreenOnErrorResumeNextStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeStatement()
            dim objectUnderTest = GenerateGreenResumeStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeLabelStatement()
            dim objectUnderTest = GenerateGreenResumeLabelStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeNextStatement()
            dim objectUnderTest = GenerateGreenResumeNextStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectBlock()
            dim objectUnderTest = GenerateGreenSelectBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectStatement()
            dim objectUnderTest = GenerateGreenSelectStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseBlock()
            dim objectUnderTest = GenerateGreenCaseBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseElseBlock()
            dim objectUnderTest = GenerateGreenCaseElseBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseStatement()
            dim objectUnderTest = GenerateGreenCaseStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseElseStatement()
            dim objectUnderTest = GenerateGreenCaseElseStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseCaseClause()
            dim objectUnderTest = GenerateGreenElseCaseClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleCaseClause()
            dim objectUnderTest = GenerateGreenSimpleCaseClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRangeCaseClause()
            dim objectUnderTest = GenerateGreenRangeCaseClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseEqualsClause()
            dim objectUnderTest = GenerateGreenCaseEqualsClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseNotEqualsClause()
            dim objectUnderTest = GenerateGreenCaseNotEqualsClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseLessThanClause()
            dim objectUnderTest = GenerateGreenCaseLessThanClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseLessThanOrEqualClause()
            dim objectUnderTest = GenerateGreenCaseLessThanOrEqualClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseGreaterThanOrEqualClause()
            dim objectUnderTest = GenerateGreenCaseGreaterThanOrEqualClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseGreaterThanClause()
            dim objectUnderTest = GenerateGreenCaseGreaterThanClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSyncLockStatement()
            dim objectUnderTest = GenerateGreenSyncLockStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleDoLoopBlock()
            dim objectUnderTest = GenerateGreenSimpleDoLoopBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoWhileLoopBlock()
            dim objectUnderTest = GenerateGreenDoWhileLoopBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoUntilLoopBlock()
            dim objectUnderTest = GenerateGreenDoUntilLoopBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoLoopWhileBlock()
            dim objectUnderTest = GenerateGreenDoLoopWhileBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoLoopUntilBlock()
            dim objectUnderTest = GenerateGreenDoLoopUntilBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleDoStatement()
            dim objectUnderTest = GenerateGreenSimpleDoStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoWhileStatement()
            dim objectUnderTest = GenerateGreenDoWhileStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoUntilStatement()
            dim objectUnderTest = GenerateGreenDoUntilStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleLoopStatement()
            dim objectUnderTest = GenerateGreenSimpleLoopStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLoopWhileStatement()
            dim objectUnderTest = GenerateGreenLoopWhileStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLoopUntilStatement()
            dim objectUnderTest = GenerateGreenLoopUntilStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileClause()
            dim objectUnderTest = GenerateGreenWhileClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenUntilClause()
            dim objectUnderTest = GenerateGreenUntilClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileStatement()
            dim objectUnderTest = GenerateGreenWhileStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenForBlock()
            dim objectUnderTest = GenerateGreenForBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenForEachBlock()
            dim objectUnderTest = GenerateGreenForEachBlock()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenForStatement()
            dim objectUnderTest = GenerateGreenForStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenForStepClause()
            dim objectUnderTest = GenerateGreenForStepClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenForEachStatement()
            dim objectUnderTest = GenerateGreenForEachStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNextStatement()
            dim objectUnderTest = GenerateGreenNextStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenUsingStatement()
            dim objectUnderTest = GenerateGreenUsingStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenThrowStatement()
            dim objectUnderTest = GenerateGreenThrowStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleAssignmentStatement()
            dim objectUnderTest = GenerateGreenSimpleAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMidAssignmentStatement()
            dim objectUnderTest = GenerateGreenMidAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddAssignmentStatement()
            dim objectUnderTest = GenerateGreenAddAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubtractAssignmentStatement()
            dim objectUnderTest = GenerateGreenSubtractAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiplyAssignmentStatement()
            dim objectUnderTest = GenerateGreenMultiplyAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDivideAssignmentStatement()
            dim objectUnderTest = GenerateGreenDivideAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIntegerDivideAssignmentStatement()
            dim objectUnderTest = GenerateGreenIntegerDivideAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExponentiateAssignmentStatement()
            dim objectUnderTest = GenerateGreenExponentiateAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLeftShiftAssignmentStatement()
            dim objectUnderTest = GenerateGreenLeftShiftAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRightShiftAssignmentStatement()
            dim objectUnderTest = GenerateGreenRightShiftAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenConcatenateAssignmentStatement()
            dim objectUnderTest = GenerateGreenConcatenateAssignmentStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMidExpression()
            dim objectUnderTest = GenerateGreenMidExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCallStatement()
            dim objectUnderTest = GenerateGreenCallStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerStatement()
            dim objectUnderTest = GenerateGreenAddHandlerStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerStatement()
            dim objectUnderTest = GenerateGreenRemoveHandlerStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventStatement()
            dim objectUnderTest = GenerateGreenRaiseEventStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithStatement()
            dim objectUnderTest = GenerateGreenWithStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenReDimStatement()
            dim objectUnderTest = GenerateGreenReDimStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenReDimPreserveStatement()
            dim objectUnderTest = GenerateGreenReDimPreserveStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRedimClause()
            dim objectUnderTest = GenerateGreenRedimClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEraseStatement()
            dim objectUnderTest = GenerateGreenEraseStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCharacterLiteralExpression()
            dim objectUnderTest = GenerateGreenCharacterLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTrueLiteralExpression()
            dim objectUnderTest = GenerateGreenTrueLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFalseLiteralExpression()
            dim objectUnderTest = GenerateGreenFalseLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNumericLiteralExpression()
            dim objectUnderTest = GenerateGreenNumericLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDateLiteralExpression()
            dim objectUnderTest = GenerateGreenDateLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenStringLiteralExpression()
            dim objectUnderTest = GenerateGreenStringLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNothingLiteralExpression()
            dim objectUnderTest = GenerateGreenNothingLiteralExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenParenthesizedExpression()
            dim objectUnderTest = GenerateGreenParenthesizedExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTupleExpression()
            dim objectUnderTest = GenerateGreenTupleExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTupleType()
            dim objectUnderTest = GenerateGreenTupleType()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypedTupleElement()
            dim objectUnderTest = GenerateGreenTypedTupleElement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamedTupleElement()
            dim objectUnderTest = GenerateGreenNamedTupleElement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMeExpression()
            dim objectUnderTest = GenerateGreenMeExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMyBaseExpression()
            dim objectUnderTest = GenerateGreenMyBaseExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMyClassExpression()
            dim objectUnderTest = GenerateGreenMyClassExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetTypeExpression()
            dim objectUnderTest = GenerateGreenGetTypeExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeOfIsExpression()
            dim objectUnderTest = GenerateGreenTypeOfIsExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeOfIsNotExpression()
            dim objectUnderTest = GenerateGreenTypeOfIsNotExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetXmlNamespaceExpression()
            dim objectUnderTest = GenerateGreenGetXmlNamespaceExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleMemberAccessExpression()
            dim objectUnderTest = GenerateGreenSimpleMemberAccessExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDictionaryAccessExpression()
            dim objectUnderTest = GenerateGreenDictionaryAccessExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementAccessExpression()
            dim objectUnderTest = GenerateGreenXmlElementAccessExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDescendantAccessExpression()
            dim objectUnderTest = GenerateGreenXmlDescendantAccessExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlAttributeAccessExpression()
            dim objectUnderTest = GenerateGreenXmlAttributeAccessExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInvocationExpression()
            dim objectUnderTest = GenerateGreenInvocationExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectCreationExpression()
            dim objectUnderTest = GenerateGreenObjectCreationExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAnonymousObjectCreationExpression()
            dim objectUnderTest = GenerateGreenAnonymousObjectCreationExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayCreationExpression()
            dim objectUnderTest = GenerateGreenArrayCreationExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCollectionInitializer()
            dim objectUnderTest = GenerateGreenCollectionInitializer()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCTypeExpression()
            dim objectUnderTest = GenerateGreenCTypeExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDirectCastExpression()
            dim objectUnderTest = GenerateGreenDirectCastExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryCastExpression()
            dim objectUnderTest = GenerateGreenTryCastExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenPredefinedCastExpression()
            dim objectUnderTest = GenerateGreenPredefinedCastExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddExpression()
            dim objectUnderTest = GenerateGreenAddExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubtractExpression()
            dim objectUnderTest = GenerateGreenSubtractExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiplyExpression()
            dim objectUnderTest = GenerateGreenMultiplyExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDivideExpression()
            dim objectUnderTest = GenerateGreenDivideExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIntegerDivideExpression()
            dim objectUnderTest = GenerateGreenIntegerDivideExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExponentiateExpression()
            dim objectUnderTest = GenerateGreenExponentiateExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLeftShiftExpression()
            dim objectUnderTest = GenerateGreenLeftShiftExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRightShiftExpression()
            dim objectUnderTest = GenerateGreenRightShiftExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenConcatenateExpression()
            dim objectUnderTest = GenerateGreenConcatenateExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuloExpression()
            dim objectUnderTest = GenerateGreenModuloExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEqualsExpression()
            dim objectUnderTest = GenerateGreenEqualsExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNotEqualsExpression()
            dim objectUnderTest = GenerateGreenNotEqualsExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLessThanExpression()
            dim objectUnderTest = GenerateGreenLessThanExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLessThanOrEqualExpression()
            dim objectUnderTest = GenerateGreenLessThanOrEqualExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGreaterThanOrEqualExpression()
            dim objectUnderTest = GenerateGreenGreaterThanOrEqualExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGreaterThanExpression()
            dim objectUnderTest = GenerateGreenGreaterThanExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIsExpression()
            dim objectUnderTest = GenerateGreenIsExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIsNotExpression()
            dim objectUnderTest = GenerateGreenIsNotExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLikeExpression()
            dim objectUnderTest = GenerateGreenLikeExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrExpression()
            dim objectUnderTest = GenerateGreenOrExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExclusiveOrExpression()
            dim objectUnderTest = GenerateGreenExclusiveOrExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAndExpression()
            dim objectUnderTest = GenerateGreenAndExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrElseExpression()
            dim objectUnderTest = GenerateGreenOrElseExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAndAlsoExpression()
            dim objectUnderTest = GenerateGreenAndAlsoExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenUnaryPlusExpression()
            dim objectUnderTest = GenerateGreenUnaryPlusExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenUnaryMinusExpression()
            dim objectUnderTest = GenerateGreenUnaryMinusExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNotExpression()
            dim objectUnderTest = GenerateGreenNotExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddressOfExpression()
            dim objectUnderTest = GenerateGreenAddressOfExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenBinaryConditionalExpression()
            dim objectUnderTest = GenerateGreenBinaryConditionalExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTernaryConditionalExpression()
            dim objectUnderTest = GenerateGreenTernaryConditionalExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineFunctionLambdaExpression()
            dim objectUnderTest = GenerateGreenSingleLineFunctionLambdaExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineSubLambdaExpression()
            dim objectUnderTest = GenerateGreenSingleLineSubLambdaExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineFunctionLambdaExpression()
            dim objectUnderTest = GenerateGreenMultiLineFunctionLambdaExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineSubLambdaExpression()
            dim objectUnderTest = GenerateGreenMultiLineSubLambdaExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubLambdaHeader()
            dim objectUnderTest = GenerateGreenSubLambdaHeader()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionLambdaHeader()
            dim objectUnderTest = GenerateGreenFunctionLambdaHeader()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenArgumentList()
            dim objectUnderTest = GenerateGreenArgumentList()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOmittedArgument()
            dim objectUnderTest = GenerateGreenOmittedArgument()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleArgument()
            dim objectUnderTest = GenerateGreenSimpleArgument()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNameColonEquals()
            dim objectUnderTest = GenerateGreenNameColonEquals()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRangeArgument()
            dim objectUnderTest = GenerateGreenRangeArgument()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenQueryExpression()
            dim objectUnderTest = GenerateGreenQueryExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCollectionRangeVariable()
            dim objectUnderTest = GenerateGreenCollectionRangeVariable()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExpressionRangeVariable()
            dim objectUnderTest = GenerateGreenExpressionRangeVariable()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAggregationRangeVariable()
            dim objectUnderTest = GenerateGreenAggregationRangeVariable()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenVariableNameEquals()
            dim objectUnderTest = GenerateGreenVariableNameEquals()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionAggregation()
            dim objectUnderTest = GenerateGreenFunctionAggregation()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupAggregation()
            dim objectUnderTest = GenerateGreenGroupAggregation()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenFromClause()
            dim objectUnderTest = GenerateGreenFromClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLetClause()
            dim objectUnderTest = GenerateGreenLetClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAggregateClause()
            dim objectUnderTest = GenerateGreenAggregateClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDistinctClause()
            dim objectUnderTest = GenerateGreenDistinctClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhereClause()
            dim objectUnderTest = GenerateGreenWhereClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkipWhileClause()
            dim objectUnderTest = GenerateGreenSkipWhileClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTakeWhileClause()
            dim objectUnderTest = GenerateGreenTakeWhileClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkipClause()
            dim objectUnderTest = GenerateGreenSkipClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTakeClause()
            dim objectUnderTest = GenerateGreenTakeClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupByClause()
            dim objectUnderTest = GenerateGreenGroupByClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenJoinCondition()
            dim objectUnderTest = GenerateGreenJoinCondition()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleJoinClause()
            dim objectUnderTest = GenerateGreenSimpleJoinClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupJoinClause()
            dim objectUnderTest = GenerateGreenGroupJoinClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrderByClause()
            dim objectUnderTest = GenerateGreenOrderByClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAscendingOrdering()
            dim objectUnderTest = GenerateGreenAscendingOrdering()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDescendingOrdering()
            dim objectUnderTest = GenerateGreenDescendingOrdering()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectClause()
            dim objectUnderTest = GenerateGreenSelectClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDocument()
            dim objectUnderTest = GenerateGreenXmlDocument()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDeclaration()
            dim objectUnderTest = GenerateGreenXmlDeclaration()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDeclarationOption()
            dim objectUnderTest = GenerateGreenXmlDeclarationOption()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElement()
            dim objectUnderTest = GenerateGreenXmlElement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlText()
            dim objectUnderTest = GenerateGreenXmlText()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementStartTag()
            dim objectUnderTest = GenerateGreenXmlElementStartTag()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementEndTag()
            dim objectUnderTest = GenerateGreenXmlElementEndTag()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEmptyElement()
            dim objectUnderTest = GenerateGreenXmlEmptyElement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlAttribute()
            dim objectUnderTest = GenerateGreenXmlAttribute()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlString()
            dim objectUnderTest = GenerateGreenXmlString()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlPrefixName()
            dim objectUnderTest = GenerateGreenXmlPrefixName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlName()
            dim objectUnderTest = GenerateGreenXmlName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlBracketedName()
            dim objectUnderTest = GenerateGreenXmlBracketedName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlPrefix()
            dim objectUnderTest = GenerateGreenXmlPrefix()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlComment()
            dim objectUnderTest = GenerateGreenXmlComment()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlProcessingInstruction()
            dim objectUnderTest = GenerateGreenXmlProcessingInstruction()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCDataSection()
            dim objectUnderTest = GenerateGreenXmlCDataSection()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEmbeddedExpression()
            dim objectUnderTest = GenerateGreenXmlEmbeddedExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayType()
            dim objectUnderTest = GenerateGreenArrayType()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNullableType()
            dim objectUnderTest = GenerateGreenNullableType()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenPredefinedType()
            dim objectUnderTest = GenerateGreenPredefinedType()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIdentifierName()
            dim objectUnderTest = GenerateGreenIdentifierName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGenericName()
            dim objectUnderTest = GenerateGreenGenericName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenQualifiedName()
            dim objectUnderTest = GenerateGreenQualifiedName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenGlobalName()
            dim objectUnderTest = GenerateGreenGlobalName()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeArgumentList()
            dim objectUnderTest = GenerateGreenTypeArgumentList()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefReference()
            dim objectUnderTest = GenerateGreenCrefReference()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefSignature()
            dim objectUnderTest = GenerateGreenCrefSignature()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefSignaturePart()
            dim objectUnderTest = GenerateGreenCrefSignaturePart()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefOperatorReference()
            dim objectUnderTest = GenerateGreenCrefOperatorReference()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenQualifiedCrefOperatorReference()
            dim objectUnderTest = GenerateGreenQualifiedCrefOperatorReference()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenYieldStatement()
            dim objectUnderTest = GenerateGreenYieldStatement()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenAwaitExpression()
            dim objectUnderTest = GenerateGreenAwaitExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNameToken()
            dim objectUnderTest = GenerateGreenXmlNameToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlTextLiteralToken()
            dim objectUnderTest = GenerateGreenXmlTextLiteralToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEntityLiteralToken()
            dim objectUnderTest = GenerateGreenXmlEntityLiteralToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDocumentationCommentLineBreakToken()
            dim objectUnderTest = GenerateGreenDocumentationCommentLineBreakToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringTextToken()
            dim objectUnderTest = GenerateGreenInterpolatedStringTextToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDecimalLiteralToken()
            dim objectUnderTest = GenerateGreenDecimalLiteralToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDateLiteralToken()
            dim objectUnderTest = GenerateGreenDateLiteralToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenStringLiteralToken()
            dim objectUnderTest = GenerateGreenStringLiteralToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCharacterLiteralToken()
            dim objectUnderTest = GenerateGreenCharacterLiteralToken()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkippedTokensTrivia()
            dim objectUnderTest = GenerateGreenSkippedTokensTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDocumentationCommentTrivia()
            dim objectUnderTest = GenerateGreenDocumentationCommentTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCrefAttribute()
            dim objectUnderTest = GenerateGreenXmlCrefAttribute()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNameAttribute()
            dim objectUnderTest = GenerateGreenXmlNameAttribute()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenConditionalAccessExpression()
            dim objectUnderTest = GenerateGreenConditionalAccessExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenNameOfExpression()
            dim objectUnderTest = GenerateGreenNameOfExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringExpression()
            dim objectUnderTest = GenerateGreenInterpolatedStringExpression()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringText()
            dim objectUnderTest = GenerateGreenInterpolatedStringText()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolation()
            dim objectUnderTest = GenerateGreenInterpolation()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationAlignmentClause()
            dim objectUnderTest = GenerateGreenInterpolationAlignmentClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationFormatClause()
            dim objectUnderTest = GenerateGreenInterpolationFormatClause()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhitespaceTrivia()
            dim objectUnderTest = GenerateGreenWhitespaceTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndOfLineTrivia()
            dim objectUnderTest = GenerateGreenEndOfLineTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenColonTrivia()
            dim objectUnderTest = GenerateGreenColonTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenCommentTrivia()
            dim objectUnderTest = GenerateGreenCommentTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenConflictMarkerTrivia()
            dim objectUnderTest = GenerateGreenConflictMarkerTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenLineContinuationTrivia()
            dim objectUnderTest = GenerateGreenLineContinuationTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDocumentationCommentExteriorTrivia()
            dim objectUnderTest = GenerateGreenDocumentationCommentExteriorTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDisabledTextTrivia()
            dim objectUnderTest = GenerateGreenDisabledTextTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenConstDirectiveTrivia()
            dim objectUnderTest = GenerateGreenConstDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenIfDirectiveTrivia()
            dim objectUnderTest = GenerateGreenIfDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfDirectiveTrivia()
            dim objectUnderTest = GenerateGreenElseIfDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseDirectiveTrivia()
            dim objectUnderTest = GenerateGreenElseDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndIfDirectiveTrivia()
            dim objectUnderTest = GenerateGreenEndIfDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenRegionDirectiveTrivia()
            dim objectUnderTest = GenerateGreenRegionDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRegionDirectiveTrivia()
            dim objectUnderTest = GenerateGreenEndRegionDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenExternalChecksumDirectiveTrivia()
            dim objectUnderTest = GenerateGreenExternalChecksumDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnableWarningDirectiveTrivia()
            dim objectUnderTest = GenerateGreenEnableWarningDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenDisableWarningDirectiveTrivia()
            dim objectUnderTest = GenerateGreenDisableWarningDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenReferenceDirectiveTrivia()
            dim objectUnderTest = GenerateGreenReferenceDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestGreenBadDirectiveTrivia()
            dim objectUnderTest = GenerateGreenBadDirectiveTrivia()
            AttachAndCheckDiagnostics(objectUnderTest)
        End Sub
 
#end region
 
#region "Green Rewriter Tests"
        <Fact>
        Public Sub TestGreenEmptyStatementRewriter()
            dim oldNode = GenerateGreenEmptyStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndIfStatementRewriter()
            dim oldNode = GenerateGreenEndIfStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndUsingStatementRewriter()
            dim oldNode = GenerateGreenEndUsingStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndWithStatementRewriter()
            dim oldNode = GenerateGreenEndWithStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSelectStatementRewriter()
            dim oldNode = GenerateGreenEndSelectStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndStructureStatementRewriter()
            dim oldNode = GenerateGreenEndStructureStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndEnumStatementRewriter()
            dim oldNode = GenerateGreenEndEnumStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndInterfaceStatementRewriter()
            dim oldNode = GenerateGreenEndInterfaceStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndClassStatementRewriter()
            dim oldNode = GenerateGreenEndClassStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndModuleStatementRewriter()
            dim oldNode = GenerateGreenEndModuleStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndNamespaceStatementRewriter()
            dim oldNode = GenerateGreenEndNamespaceStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSubStatementRewriter()
            dim oldNode = GenerateGreenEndSubStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndFunctionStatementRewriter()
            dim oldNode = GenerateGreenEndFunctionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndGetStatementRewriter()
            dim oldNode = GenerateGreenEndGetStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSetStatementRewriter()
            dim oldNode = GenerateGreenEndSetStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndPropertyStatementRewriter()
            dim oldNode = GenerateGreenEndPropertyStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndOperatorStatementRewriter()
            dim oldNode = GenerateGreenEndOperatorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndEventStatementRewriter()
            dim oldNode = GenerateGreenEndEventStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndAddHandlerStatementRewriter()
            dim oldNode = GenerateGreenEndAddHandlerStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRemoveHandlerStatementRewriter()
            dim oldNode = GenerateGreenEndRemoveHandlerStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRaiseEventStatementRewriter()
            dim oldNode = GenerateGreenEndRaiseEventStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndWhileStatementRewriter()
            dim oldNode = GenerateGreenEndWhileStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndTryStatementRewriter()
            dim oldNode = GenerateGreenEndTryStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSyncLockStatementRewriter()
            dim oldNode = GenerateGreenEndSyncLockStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCompilationUnitRewriter()
            dim oldNode = GenerateGreenCompilationUnit()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOptionStatementRewriter()
            dim oldNode = GenerateGreenOptionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImportsStatementRewriter()
            dim oldNode = GenerateGreenImportsStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleImportsClauseRewriter()
            dim oldNode = GenerateGreenSimpleImportsClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImportAliasClauseRewriter()
            dim oldNode = GenerateGreenImportAliasClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNamespaceImportsClauseRewriter()
            dim oldNode = GenerateGreenXmlNamespaceImportsClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamespaceBlockRewriter()
            dim oldNode = GenerateGreenNamespaceBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamespaceStatementRewriter()
            dim oldNode = GenerateGreenNamespaceStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuleBlockRewriter()
            dim oldNode = GenerateGreenModuleBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureBlockRewriter()
            dim oldNode = GenerateGreenStructureBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterfaceBlockRewriter()
            dim oldNode = GenerateGreenInterfaceBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassBlockRewriter()
            dim oldNode = GenerateGreenClassBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumBlockRewriter()
            dim oldNode = GenerateGreenEnumBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInheritsStatementRewriter()
            dim oldNode = GenerateGreenInheritsStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImplementsStatementRewriter()
            dim oldNode = GenerateGreenImplementsStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuleStatementRewriter()
            dim oldNode = GenerateGreenModuleStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureStatementRewriter()
            dim oldNode = GenerateGreenStructureStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterfaceStatementRewriter()
            dim oldNode = GenerateGreenInterfaceStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassStatementRewriter()
            dim oldNode = GenerateGreenClassStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumStatementRewriter()
            dim oldNode = GenerateGreenEnumStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterListRewriter()
            dim oldNode = GenerateGreenTypeParameterList()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterRewriter()
            dim oldNode = GenerateGreenTypeParameter()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterSingleConstraintClauseRewriter()
            dim oldNode = GenerateGreenTypeParameterSingleConstraintClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterMultipleConstraintClauseRewriter()
            dim oldNode = GenerateGreenTypeParameterMultipleConstraintClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNewConstraintRewriter()
            dim oldNode = GenerateGreenNewConstraint()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassConstraintRewriter()
            dim oldNode = GenerateGreenClassConstraint()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureConstraintRewriter()
            dim oldNode = GenerateGreenStructureConstraint()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeConstraintRewriter()
            dim oldNode = GenerateGreenTypeConstraint()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumMemberDeclarationRewriter()
            dim oldNode = GenerateGreenEnumMemberDeclaration()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubBlockRewriter()
            dim oldNode = GenerateGreenSubBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionBlockRewriter()
            dim oldNode = GenerateGreenFunctionBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConstructorBlockRewriter()
            dim oldNode = GenerateGreenConstructorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOperatorBlockRewriter()
            dim oldNode = GenerateGreenOperatorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetAccessorBlockRewriter()
            dim oldNode = GenerateGreenGetAccessorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSetAccessorBlockRewriter()
            dim oldNode = GenerateGreenSetAccessorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerAccessorBlockRewriter()
            dim oldNode = GenerateGreenAddHandlerAccessorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerAccessorBlockRewriter()
            dim oldNode = GenerateGreenRemoveHandlerAccessorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventAccessorBlockRewriter()
            dim oldNode = GenerateGreenRaiseEventAccessorBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPropertyBlockRewriter()
            dim oldNode = GenerateGreenPropertyBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEventBlockRewriter()
            dim oldNode = GenerateGreenEventBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenParameterListRewriter()
            dim oldNode = GenerateGreenParameterList()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubStatementRewriter()
            dim oldNode = GenerateGreenSubStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionStatementRewriter()
            dim oldNode = GenerateGreenFunctionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubNewStatementRewriter()
            dim oldNode = GenerateGreenSubNewStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDeclareSubStatementRewriter()
            dim oldNode = GenerateGreenDeclareSubStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDeclareFunctionStatementRewriter()
            dim oldNode = GenerateGreenDeclareFunctionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDelegateSubStatementRewriter()
            dim oldNode = GenerateGreenDelegateSubStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDelegateFunctionStatementRewriter()
            dim oldNode = GenerateGreenDelegateFunctionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEventStatementRewriter()
            dim oldNode = GenerateGreenEventStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOperatorStatementRewriter()
            dim oldNode = GenerateGreenOperatorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPropertyStatementRewriter()
            dim oldNode = GenerateGreenPropertyStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetAccessorStatementRewriter()
            dim oldNode = GenerateGreenGetAccessorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSetAccessorStatementRewriter()
            dim oldNode = GenerateGreenSetAccessorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerAccessorStatementRewriter()
            dim oldNode = GenerateGreenAddHandlerAccessorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerAccessorStatementRewriter()
            dim oldNode = GenerateGreenRemoveHandlerAccessorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventAccessorStatementRewriter()
            dim oldNode = GenerateGreenRaiseEventAccessorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImplementsClauseRewriter()
            dim oldNode = GenerateGreenImplementsClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenHandlesClauseRewriter()
            dim oldNode = GenerateGreenHandlesClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenKeywordEventContainerRewriter()
            dim oldNode = GenerateGreenKeywordEventContainer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithEventsEventContainerRewriter()
            dim oldNode = GenerateGreenWithEventsEventContainer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithEventsPropertyEventContainerRewriter()
            dim oldNode = GenerateGreenWithEventsPropertyEventContainer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenHandlesClauseItemRewriter()
            dim oldNode = GenerateGreenHandlesClauseItem()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIncompleteMemberRewriter()
            dim oldNode = GenerateGreenIncompleteMember()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFieldDeclarationRewriter()
            dim oldNode = GenerateGreenFieldDeclaration()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenVariableDeclaratorRewriter()
            dim oldNode = GenerateGreenVariableDeclarator()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleAsClauseRewriter()
            dim oldNode = GenerateGreenSimpleAsClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAsNewClauseRewriter()
            dim oldNode = GenerateGreenAsNewClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectMemberInitializerRewriter()
            dim oldNode = GenerateGreenObjectMemberInitializer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectCollectionInitializerRewriter()
            dim oldNode = GenerateGreenObjectCollectionInitializer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInferredFieldInitializerRewriter()
            dim oldNode = GenerateGreenInferredFieldInitializer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamedFieldInitializerRewriter()
            dim oldNode = GenerateGreenNamedFieldInitializer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEqualsValueRewriter()
            dim oldNode = GenerateGreenEqualsValue()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenParameterRewriter()
            dim oldNode = GenerateGreenParameter()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModifiedIdentifierRewriter()
            dim oldNode = GenerateGreenModifiedIdentifier()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayRankSpecifierRewriter()
            dim oldNode = GenerateGreenArrayRankSpecifier()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeListRewriter()
            dim oldNode = GenerateGreenAttributeList()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeRewriter()
            dim oldNode = GenerateGreenAttribute()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeTargetRewriter()
            dim oldNode = GenerateGreenAttributeTarget()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributesStatementRewriter()
            dim oldNode = GenerateGreenAttributesStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExpressionStatementRewriter()
            dim oldNode = GenerateGreenExpressionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPrintStatementRewriter()
            dim oldNode = GenerateGreenPrintStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileBlockRewriter()
            dim oldNode = GenerateGreenWhileBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUsingBlockRewriter()
            dim oldNode = GenerateGreenUsingBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSyncLockBlockRewriter()
            dim oldNode = GenerateGreenSyncLockBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithBlockRewriter()
            dim oldNode = GenerateGreenWithBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLocalDeclarationStatementRewriter()
            dim oldNode = GenerateGreenLocalDeclarationStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLabelStatementRewriter()
            dim oldNode = GenerateGreenLabelStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGoToStatementRewriter()
            dim oldNode = GenerateGreenGoToStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIdentifierLabelRewriter()
            dim oldNode = GenerateGreenIdentifierLabel()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNumericLabelRewriter()
            dim oldNode = GenerateGreenNumericLabel()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNextLabelRewriter()
            dim oldNode = GenerateGreenNextLabel()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStopStatementRewriter()
            dim oldNode = GenerateGreenStopStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndStatementRewriter()
            dim oldNode = GenerateGreenEndStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitDoStatementRewriter()
            dim oldNode = GenerateGreenExitDoStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitForStatementRewriter()
            dim oldNode = GenerateGreenExitForStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitSubStatementRewriter()
            dim oldNode = GenerateGreenExitSubStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitFunctionStatementRewriter()
            dim oldNode = GenerateGreenExitFunctionStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitOperatorStatementRewriter()
            dim oldNode = GenerateGreenExitOperatorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitPropertyStatementRewriter()
            dim oldNode = GenerateGreenExitPropertyStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitTryStatementRewriter()
            dim oldNode = GenerateGreenExitTryStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitSelectStatementRewriter()
            dim oldNode = GenerateGreenExitSelectStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitWhileStatementRewriter()
            dim oldNode = GenerateGreenExitWhileStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueWhileStatementRewriter()
            dim oldNode = GenerateGreenContinueWhileStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueDoStatementRewriter()
            dim oldNode = GenerateGreenContinueDoStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueForStatementRewriter()
            dim oldNode = GenerateGreenContinueForStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReturnStatementRewriter()
            dim oldNode = GenerateGreenReturnStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineIfStatementRewriter()
            dim oldNode = GenerateGreenSingleLineIfStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineElseClauseRewriter()
            dim oldNode = GenerateGreenSingleLineElseClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineIfBlockRewriter()
            dim oldNode = GenerateGreenMultiLineIfBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIfStatementRewriter()
            dim oldNode = GenerateGreenIfStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfBlockRewriter()
            dim oldNode = GenerateGreenElseIfBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfStatementRewriter()
            dim oldNode = GenerateGreenElseIfStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseBlockRewriter()
            dim oldNode = GenerateGreenElseBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseStatementRewriter()
            dim oldNode = GenerateGreenElseStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryBlockRewriter()
            dim oldNode = GenerateGreenTryBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryStatementRewriter()
            dim oldNode = GenerateGreenTryStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchBlockRewriter()
            dim oldNode = GenerateGreenCatchBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchStatementRewriter()
            dim oldNode = GenerateGreenCatchStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchFilterClauseRewriter()
            dim oldNode = GenerateGreenCatchFilterClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFinallyBlockRewriter()
            dim oldNode = GenerateGreenFinallyBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFinallyStatementRewriter()
            dim oldNode = GenerateGreenFinallyStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenErrorStatementRewriter()
            dim oldNode = GenerateGreenErrorStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToZeroStatementRewriter()
            dim oldNode = GenerateGreenOnErrorGoToZeroStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToMinusOneStatementRewriter()
            dim oldNode = GenerateGreenOnErrorGoToMinusOneStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToLabelStatementRewriter()
            dim oldNode = GenerateGreenOnErrorGoToLabelStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorResumeNextStatementRewriter()
            dim oldNode = GenerateGreenOnErrorResumeNextStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeStatementRewriter()
            dim oldNode = GenerateGreenResumeStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeLabelStatementRewriter()
            dim oldNode = GenerateGreenResumeLabelStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeNextStatementRewriter()
            dim oldNode = GenerateGreenResumeNextStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectBlockRewriter()
            dim oldNode = GenerateGreenSelectBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectStatementRewriter()
            dim oldNode = GenerateGreenSelectStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseBlockRewriter()
            dim oldNode = GenerateGreenCaseBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseElseBlockRewriter()
            dim oldNode = GenerateGreenCaseElseBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseStatementRewriter()
            dim oldNode = GenerateGreenCaseStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseElseStatementRewriter()
            dim oldNode = GenerateGreenCaseElseStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseCaseClauseRewriter()
            dim oldNode = GenerateGreenElseCaseClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleCaseClauseRewriter()
            dim oldNode = GenerateGreenSimpleCaseClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRangeCaseClauseRewriter()
            dim oldNode = GenerateGreenRangeCaseClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseEqualsClauseRewriter()
            dim oldNode = GenerateGreenCaseEqualsClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseNotEqualsClauseRewriter()
            dim oldNode = GenerateGreenCaseNotEqualsClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseLessThanClauseRewriter()
            dim oldNode = GenerateGreenCaseLessThanClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseLessThanOrEqualClauseRewriter()
            dim oldNode = GenerateGreenCaseLessThanOrEqualClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseGreaterThanOrEqualClauseRewriter()
            dim oldNode = GenerateGreenCaseGreaterThanOrEqualClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseGreaterThanClauseRewriter()
            dim oldNode = GenerateGreenCaseGreaterThanClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSyncLockStatementRewriter()
            dim oldNode = GenerateGreenSyncLockStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleDoLoopBlockRewriter()
            dim oldNode = GenerateGreenSimpleDoLoopBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoWhileLoopBlockRewriter()
            dim oldNode = GenerateGreenDoWhileLoopBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoUntilLoopBlockRewriter()
            dim oldNode = GenerateGreenDoUntilLoopBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoLoopWhileBlockRewriter()
            dim oldNode = GenerateGreenDoLoopWhileBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoLoopUntilBlockRewriter()
            dim oldNode = GenerateGreenDoLoopUntilBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleDoStatementRewriter()
            dim oldNode = GenerateGreenSimpleDoStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoWhileStatementRewriter()
            dim oldNode = GenerateGreenDoWhileStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoUntilStatementRewriter()
            dim oldNode = GenerateGreenDoUntilStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleLoopStatementRewriter()
            dim oldNode = GenerateGreenSimpleLoopStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLoopWhileStatementRewriter()
            dim oldNode = GenerateGreenLoopWhileStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLoopUntilStatementRewriter()
            dim oldNode = GenerateGreenLoopUntilStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileClauseRewriter()
            dim oldNode = GenerateGreenWhileClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUntilClauseRewriter()
            dim oldNode = GenerateGreenUntilClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileStatementRewriter()
            dim oldNode = GenerateGreenWhileStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForBlockRewriter()
            dim oldNode = GenerateGreenForBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForEachBlockRewriter()
            dim oldNode = GenerateGreenForEachBlock()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForStatementRewriter()
            dim oldNode = GenerateGreenForStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForStepClauseRewriter()
            dim oldNode = GenerateGreenForStepClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForEachStatementRewriter()
            dim oldNode = GenerateGreenForEachStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNextStatementRewriter()
            dim oldNode = GenerateGreenNextStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUsingStatementRewriter()
            dim oldNode = GenerateGreenUsingStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenThrowStatementRewriter()
            dim oldNode = GenerateGreenThrowStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleAssignmentStatementRewriter()
            dim oldNode = GenerateGreenSimpleAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMidAssignmentStatementRewriter()
            dim oldNode = GenerateGreenMidAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddAssignmentStatementRewriter()
            dim oldNode = GenerateGreenAddAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubtractAssignmentStatementRewriter()
            dim oldNode = GenerateGreenSubtractAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiplyAssignmentStatementRewriter()
            dim oldNode = GenerateGreenMultiplyAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDivideAssignmentStatementRewriter()
            dim oldNode = GenerateGreenDivideAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIntegerDivideAssignmentStatementRewriter()
            dim oldNode = GenerateGreenIntegerDivideAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExponentiateAssignmentStatementRewriter()
            dim oldNode = GenerateGreenExponentiateAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLeftShiftAssignmentStatementRewriter()
            dim oldNode = GenerateGreenLeftShiftAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRightShiftAssignmentStatementRewriter()
            dim oldNode = GenerateGreenRightShiftAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConcatenateAssignmentStatementRewriter()
            dim oldNode = GenerateGreenConcatenateAssignmentStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMidExpressionRewriter()
            dim oldNode = GenerateGreenMidExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCallStatementRewriter()
            dim oldNode = GenerateGreenCallStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerStatementRewriter()
            dim oldNode = GenerateGreenAddHandlerStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerStatementRewriter()
            dim oldNode = GenerateGreenRemoveHandlerStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventStatementRewriter()
            dim oldNode = GenerateGreenRaiseEventStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithStatementRewriter()
            dim oldNode = GenerateGreenWithStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReDimStatementRewriter()
            dim oldNode = GenerateGreenReDimStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReDimPreserveStatementRewriter()
            dim oldNode = GenerateGreenReDimPreserveStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRedimClauseRewriter()
            dim oldNode = GenerateGreenRedimClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEraseStatementRewriter()
            dim oldNode = GenerateGreenEraseStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCharacterLiteralExpressionRewriter()
            dim oldNode = GenerateGreenCharacterLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTrueLiteralExpressionRewriter()
            dim oldNode = GenerateGreenTrueLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFalseLiteralExpressionRewriter()
            dim oldNode = GenerateGreenFalseLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNumericLiteralExpressionRewriter()
            dim oldNode = GenerateGreenNumericLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDateLiteralExpressionRewriter()
            dim oldNode = GenerateGreenDateLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStringLiteralExpressionRewriter()
            dim oldNode = GenerateGreenStringLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNothingLiteralExpressionRewriter()
            dim oldNode = GenerateGreenNothingLiteralExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenParenthesizedExpressionRewriter()
            dim oldNode = GenerateGreenParenthesizedExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTupleExpressionRewriter()
            dim oldNode = GenerateGreenTupleExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTupleTypeRewriter()
            dim oldNode = GenerateGreenTupleType()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypedTupleElementRewriter()
            dim oldNode = GenerateGreenTypedTupleElement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamedTupleElementRewriter()
            dim oldNode = GenerateGreenNamedTupleElement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMeExpressionRewriter()
            dim oldNode = GenerateGreenMeExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMyBaseExpressionRewriter()
            dim oldNode = GenerateGreenMyBaseExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMyClassExpressionRewriter()
            dim oldNode = GenerateGreenMyClassExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetTypeExpressionRewriter()
            dim oldNode = GenerateGreenGetTypeExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeOfIsExpressionRewriter()
            dim oldNode = GenerateGreenTypeOfIsExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeOfIsNotExpressionRewriter()
            dim oldNode = GenerateGreenTypeOfIsNotExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetXmlNamespaceExpressionRewriter()
            dim oldNode = GenerateGreenGetXmlNamespaceExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleMemberAccessExpressionRewriter()
            dim oldNode = GenerateGreenSimpleMemberAccessExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDictionaryAccessExpressionRewriter()
            dim oldNode = GenerateGreenDictionaryAccessExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementAccessExpressionRewriter()
            dim oldNode = GenerateGreenXmlElementAccessExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDescendantAccessExpressionRewriter()
            dim oldNode = GenerateGreenXmlDescendantAccessExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlAttributeAccessExpressionRewriter()
            dim oldNode = GenerateGreenXmlAttributeAccessExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInvocationExpressionRewriter()
            dim oldNode = GenerateGreenInvocationExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectCreationExpressionRewriter()
            dim oldNode = GenerateGreenObjectCreationExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAnonymousObjectCreationExpressionRewriter()
            dim oldNode = GenerateGreenAnonymousObjectCreationExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayCreationExpressionRewriter()
            dim oldNode = GenerateGreenArrayCreationExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCollectionInitializerRewriter()
            dim oldNode = GenerateGreenCollectionInitializer()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCTypeExpressionRewriter()
            dim oldNode = GenerateGreenCTypeExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDirectCastExpressionRewriter()
            dim oldNode = GenerateGreenDirectCastExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryCastExpressionRewriter()
            dim oldNode = GenerateGreenTryCastExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPredefinedCastExpressionRewriter()
            dim oldNode = GenerateGreenPredefinedCastExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddExpressionRewriter()
            dim oldNode = GenerateGreenAddExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubtractExpressionRewriter()
            dim oldNode = GenerateGreenSubtractExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiplyExpressionRewriter()
            dim oldNode = GenerateGreenMultiplyExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDivideExpressionRewriter()
            dim oldNode = GenerateGreenDivideExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIntegerDivideExpressionRewriter()
            dim oldNode = GenerateGreenIntegerDivideExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExponentiateExpressionRewriter()
            dim oldNode = GenerateGreenExponentiateExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLeftShiftExpressionRewriter()
            dim oldNode = GenerateGreenLeftShiftExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRightShiftExpressionRewriter()
            dim oldNode = GenerateGreenRightShiftExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConcatenateExpressionRewriter()
            dim oldNode = GenerateGreenConcatenateExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuloExpressionRewriter()
            dim oldNode = GenerateGreenModuloExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEqualsExpressionRewriter()
            dim oldNode = GenerateGreenEqualsExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNotEqualsExpressionRewriter()
            dim oldNode = GenerateGreenNotEqualsExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLessThanExpressionRewriter()
            dim oldNode = GenerateGreenLessThanExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLessThanOrEqualExpressionRewriter()
            dim oldNode = GenerateGreenLessThanOrEqualExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGreaterThanOrEqualExpressionRewriter()
            dim oldNode = GenerateGreenGreaterThanOrEqualExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGreaterThanExpressionRewriter()
            dim oldNode = GenerateGreenGreaterThanExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIsExpressionRewriter()
            dim oldNode = GenerateGreenIsExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIsNotExpressionRewriter()
            dim oldNode = GenerateGreenIsNotExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLikeExpressionRewriter()
            dim oldNode = GenerateGreenLikeExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrExpressionRewriter()
            dim oldNode = GenerateGreenOrExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExclusiveOrExpressionRewriter()
            dim oldNode = GenerateGreenExclusiveOrExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAndExpressionRewriter()
            dim oldNode = GenerateGreenAndExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrElseExpressionRewriter()
            dim oldNode = GenerateGreenOrElseExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAndAlsoExpressionRewriter()
            dim oldNode = GenerateGreenAndAlsoExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUnaryPlusExpressionRewriter()
            dim oldNode = GenerateGreenUnaryPlusExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUnaryMinusExpressionRewriter()
            dim oldNode = GenerateGreenUnaryMinusExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNotExpressionRewriter()
            dim oldNode = GenerateGreenNotExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddressOfExpressionRewriter()
            dim oldNode = GenerateGreenAddressOfExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenBinaryConditionalExpressionRewriter()
            dim oldNode = GenerateGreenBinaryConditionalExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTernaryConditionalExpressionRewriter()
            dim oldNode = GenerateGreenTernaryConditionalExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineFunctionLambdaExpressionRewriter()
            dim oldNode = GenerateGreenSingleLineFunctionLambdaExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineSubLambdaExpressionRewriter()
            dim oldNode = GenerateGreenSingleLineSubLambdaExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineFunctionLambdaExpressionRewriter()
            dim oldNode = GenerateGreenMultiLineFunctionLambdaExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineSubLambdaExpressionRewriter()
            dim oldNode = GenerateGreenMultiLineSubLambdaExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubLambdaHeaderRewriter()
            dim oldNode = GenerateGreenSubLambdaHeader()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionLambdaHeaderRewriter()
            dim oldNode = GenerateGreenFunctionLambdaHeader()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArgumentListRewriter()
            dim oldNode = GenerateGreenArgumentList()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOmittedArgumentRewriter()
            dim oldNode = GenerateGreenOmittedArgument()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleArgumentRewriter()
            dim oldNode = GenerateGreenSimpleArgument()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNameColonEqualsRewriter()
            dim oldNode = GenerateGreenNameColonEquals()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRangeArgumentRewriter()
            dim oldNode = GenerateGreenRangeArgument()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenQueryExpressionRewriter()
            dim oldNode = GenerateGreenQueryExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCollectionRangeVariableRewriter()
            dim oldNode = GenerateGreenCollectionRangeVariable()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExpressionRangeVariableRewriter()
            dim oldNode = GenerateGreenExpressionRangeVariable()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAggregationRangeVariableRewriter()
            dim oldNode = GenerateGreenAggregationRangeVariable()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenVariableNameEqualsRewriter()
            dim oldNode = GenerateGreenVariableNameEquals()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionAggregationRewriter()
            dim oldNode = GenerateGreenFunctionAggregation()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupAggregationRewriter()
            dim oldNode = GenerateGreenGroupAggregation()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFromClauseRewriter()
            dim oldNode = GenerateGreenFromClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLetClauseRewriter()
            dim oldNode = GenerateGreenLetClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAggregateClauseRewriter()
            dim oldNode = GenerateGreenAggregateClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDistinctClauseRewriter()
            dim oldNode = GenerateGreenDistinctClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhereClauseRewriter()
            dim oldNode = GenerateGreenWhereClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkipWhileClauseRewriter()
            dim oldNode = GenerateGreenSkipWhileClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTakeWhileClauseRewriter()
            dim oldNode = GenerateGreenTakeWhileClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkipClauseRewriter()
            dim oldNode = GenerateGreenSkipClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTakeClauseRewriter()
            dim oldNode = GenerateGreenTakeClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupByClauseRewriter()
            dim oldNode = GenerateGreenGroupByClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenJoinConditionRewriter()
            dim oldNode = GenerateGreenJoinCondition()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleJoinClauseRewriter()
            dim oldNode = GenerateGreenSimpleJoinClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupJoinClauseRewriter()
            dim oldNode = GenerateGreenGroupJoinClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrderByClauseRewriter()
            dim oldNode = GenerateGreenOrderByClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAscendingOrderingRewriter()
            dim oldNode = GenerateGreenAscendingOrdering()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDescendingOrderingRewriter()
            dim oldNode = GenerateGreenDescendingOrdering()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectClauseRewriter()
            dim oldNode = GenerateGreenSelectClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDocumentRewriter()
            dim oldNode = GenerateGreenXmlDocument()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDeclarationRewriter()
            dim oldNode = GenerateGreenXmlDeclaration()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDeclarationOptionRewriter()
            dim oldNode = GenerateGreenXmlDeclarationOption()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementRewriter()
            dim oldNode = GenerateGreenXmlElement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlTextRewriter()
            dim oldNode = GenerateGreenXmlText()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementStartTagRewriter()
            dim oldNode = GenerateGreenXmlElementStartTag()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementEndTagRewriter()
            dim oldNode = GenerateGreenXmlElementEndTag()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEmptyElementRewriter()
            dim oldNode = GenerateGreenXmlEmptyElement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlAttributeRewriter()
            dim oldNode = GenerateGreenXmlAttribute()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlStringRewriter()
            dim oldNode = GenerateGreenXmlString()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlPrefixNameRewriter()
            dim oldNode = GenerateGreenXmlPrefixName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNameRewriter()
            dim oldNode = GenerateGreenXmlName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlBracketedNameRewriter()
            dim oldNode = GenerateGreenXmlBracketedName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlPrefixRewriter()
            dim oldNode = GenerateGreenXmlPrefix()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCommentRewriter()
            dim oldNode = GenerateGreenXmlComment()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlProcessingInstructionRewriter()
            dim oldNode = GenerateGreenXmlProcessingInstruction()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCDataSectionRewriter()
            dim oldNode = GenerateGreenXmlCDataSection()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEmbeddedExpressionRewriter()
            dim oldNode = GenerateGreenXmlEmbeddedExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayTypeRewriter()
            dim oldNode = GenerateGreenArrayType()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNullableTypeRewriter()
            dim oldNode = GenerateGreenNullableType()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPredefinedTypeRewriter()
            dim oldNode = GenerateGreenPredefinedType()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIdentifierNameRewriter()
            dim oldNode = GenerateGreenIdentifierName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGenericNameRewriter()
            dim oldNode = GenerateGreenGenericName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenQualifiedNameRewriter()
            dim oldNode = GenerateGreenQualifiedName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGlobalNameRewriter()
            dim oldNode = GenerateGreenGlobalName()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeArgumentListRewriter()
            dim oldNode = GenerateGreenTypeArgumentList()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefReferenceRewriter()
            dim oldNode = GenerateGreenCrefReference()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefSignatureRewriter()
            dim oldNode = GenerateGreenCrefSignature()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefSignaturePartRewriter()
            dim oldNode = GenerateGreenCrefSignaturePart()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefOperatorReferenceRewriter()
            dim oldNode = GenerateGreenCrefOperatorReference()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenQualifiedCrefOperatorReferenceRewriter()
            dim oldNode = GenerateGreenQualifiedCrefOperatorReference()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenYieldStatementRewriter()
            dim oldNode = GenerateGreenYieldStatement()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAwaitExpressionRewriter()
            dim oldNode = GenerateGreenAwaitExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkippedTokensTriviaRewriter()
            dim oldNode = GenerateGreenSkippedTokensTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDocumentationCommentTriviaRewriter()
            dim oldNode = GenerateGreenDocumentationCommentTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCrefAttributeRewriter()
            dim oldNode = GenerateGreenXmlCrefAttribute()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNameAttributeRewriter()
            dim oldNode = GenerateGreenXmlNameAttribute()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConditionalAccessExpressionRewriter()
            dim oldNode = GenerateGreenConditionalAccessExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNameOfExpressionRewriter()
            dim oldNode = GenerateGreenNameOfExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringExpressionRewriter()
            dim oldNode = GenerateGreenInterpolatedStringExpression()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringTextRewriter()
            dim oldNode = GenerateGreenInterpolatedStringText()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationRewriter()
            dim oldNode = GenerateGreenInterpolation()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationAlignmentClauseRewriter()
            dim oldNode = GenerateGreenInterpolationAlignmentClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationFormatClauseRewriter()
            dim oldNode = GenerateGreenInterpolationFormatClause()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConstDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenConstDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIfDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenIfDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenElseIfDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenElseDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndIfDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenEndIfDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRegionDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenRegionDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRegionDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenEndRegionDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExternalChecksumDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenExternalChecksumDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnableWarningDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenEnableWarningDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDisableWarningDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenDisableWarningDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReferenceDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenReferenceDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenBadDirectiveTriviaRewriter()
            dim oldNode = GenerateGreenBadDirectiveTrivia()
            Dim rewriter = New GreenIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
#end region
 
#region "Green Visitor Tests"
        <Fact>
        Public Sub TestGreenEmptyStatementVisitor()
            Dim oldNode = GenerateGreenEmptyStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndIfStatementVisitor()
            Dim oldNode = GenerateGreenEndIfStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndUsingStatementVisitor()
            Dim oldNode = GenerateGreenEndUsingStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndWithStatementVisitor()
            Dim oldNode = GenerateGreenEndWithStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSelectStatementVisitor()
            Dim oldNode = GenerateGreenEndSelectStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndStructureStatementVisitor()
            Dim oldNode = GenerateGreenEndStructureStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndEnumStatementVisitor()
            Dim oldNode = GenerateGreenEndEnumStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndInterfaceStatementVisitor()
            Dim oldNode = GenerateGreenEndInterfaceStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndClassStatementVisitor()
            Dim oldNode = GenerateGreenEndClassStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndModuleStatementVisitor()
            Dim oldNode = GenerateGreenEndModuleStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndNamespaceStatementVisitor()
            Dim oldNode = GenerateGreenEndNamespaceStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSubStatementVisitor()
            Dim oldNode = GenerateGreenEndSubStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndFunctionStatementVisitor()
            Dim oldNode = GenerateGreenEndFunctionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndGetStatementVisitor()
            Dim oldNode = GenerateGreenEndGetStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSetStatementVisitor()
            Dim oldNode = GenerateGreenEndSetStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndPropertyStatementVisitor()
            Dim oldNode = GenerateGreenEndPropertyStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndOperatorStatementVisitor()
            Dim oldNode = GenerateGreenEndOperatorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndEventStatementVisitor()
            Dim oldNode = GenerateGreenEndEventStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndAddHandlerStatementVisitor()
            Dim oldNode = GenerateGreenEndAddHandlerStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRemoveHandlerStatementVisitor()
            Dim oldNode = GenerateGreenEndRemoveHandlerStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRaiseEventStatementVisitor()
            Dim oldNode = GenerateGreenEndRaiseEventStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndWhileStatementVisitor()
            Dim oldNode = GenerateGreenEndWhileStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndTryStatementVisitor()
            Dim oldNode = GenerateGreenEndTryStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndSyncLockStatementVisitor()
            Dim oldNode = GenerateGreenEndSyncLockStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCompilationUnitVisitor()
            Dim oldNode = GenerateGreenCompilationUnit()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOptionStatementVisitor()
            Dim oldNode = GenerateGreenOptionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImportsStatementVisitor()
            Dim oldNode = GenerateGreenImportsStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleImportsClauseVisitor()
            Dim oldNode = GenerateGreenSimpleImportsClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImportAliasClauseVisitor()
            Dim oldNode = GenerateGreenImportAliasClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNamespaceImportsClauseVisitor()
            Dim oldNode = GenerateGreenXmlNamespaceImportsClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamespaceBlockVisitor()
            Dim oldNode = GenerateGreenNamespaceBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamespaceStatementVisitor()
            Dim oldNode = GenerateGreenNamespaceStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuleBlockVisitor()
            Dim oldNode = GenerateGreenModuleBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureBlockVisitor()
            Dim oldNode = GenerateGreenStructureBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterfaceBlockVisitor()
            Dim oldNode = GenerateGreenInterfaceBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassBlockVisitor()
            Dim oldNode = GenerateGreenClassBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumBlockVisitor()
            Dim oldNode = GenerateGreenEnumBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInheritsStatementVisitor()
            Dim oldNode = GenerateGreenInheritsStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImplementsStatementVisitor()
            Dim oldNode = GenerateGreenImplementsStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuleStatementVisitor()
            Dim oldNode = GenerateGreenModuleStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureStatementVisitor()
            Dim oldNode = GenerateGreenStructureStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterfaceStatementVisitor()
            Dim oldNode = GenerateGreenInterfaceStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassStatementVisitor()
            Dim oldNode = GenerateGreenClassStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumStatementVisitor()
            Dim oldNode = GenerateGreenEnumStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterListVisitor()
            Dim oldNode = GenerateGreenTypeParameterList()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterVisitor()
            Dim oldNode = GenerateGreenTypeParameter()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterSingleConstraintClauseVisitor()
            Dim oldNode = GenerateGreenTypeParameterSingleConstraintClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeParameterMultipleConstraintClauseVisitor()
            Dim oldNode = GenerateGreenTypeParameterMultipleConstraintClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNewConstraintVisitor()
            Dim oldNode = GenerateGreenNewConstraint()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenClassConstraintVisitor()
            Dim oldNode = GenerateGreenClassConstraint()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStructureConstraintVisitor()
            Dim oldNode = GenerateGreenStructureConstraint()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeConstraintVisitor()
            Dim oldNode = GenerateGreenTypeConstraint()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnumMemberDeclarationVisitor()
            Dim oldNode = GenerateGreenEnumMemberDeclaration()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubBlockVisitor()
            Dim oldNode = GenerateGreenSubBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionBlockVisitor()
            Dim oldNode = GenerateGreenFunctionBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConstructorBlockVisitor()
            Dim oldNode = GenerateGreenConstructorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOperatorBlockVisitor()
            Dim oldNode = GenerateGreenOperatorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetAccessorBlockVisitor()
            Dim oldNode = GenerateGreenGetAccessorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSetAccessorBlockVisitor()
            Dim oldNode = GenerateGreenSetAccessorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerAccessorBlockVisitor()
            Dim oldNode = GenerateGreenAddHandlerAccessorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerAccessorBlockVisitor()
            Dim oldNode = GenerateGreenRemoveHandlerAccessorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventAccessorBlockVisitor()
            Dim oldNode = GenerateGreenRaiseEventAccessorBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPropertyBlockVisitor()
            Dim oldNode = GenerateGreenPropertyBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEventBlockVisitor()
            Dim oldNode = GenerateGreenEventBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenParameterListVisitor()
            Dim oldNode = GenerateGreenParameterList()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubStatementVisitor()
            Dim oldNode = GenerateGreenSubStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionStatementVisitor()
            Dim oldNode = GenerateGreenFunctionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubNewStatementVisitor()
            Dim oldNode = GenerateGreenSubNewStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDeclareSubStatementVisitor()
            Dim oldNode = GenerateGreenDeclareSubStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDeclareFunctionStatementVisitor()
            Dim oldNode = GenerateGreenDeclareFunctionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDelegateSubStatementVisitor()
            Dim oldNode = GenerateGreenDelegateSubStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDelegateFunctionStatementVisitor()
            Dim oldNode = GenerateGreenDelegateFunctionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEventStatementVisitor()
            Dim oldNode = GenerateGreenEventStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOperatorStatementVisitor()
            Dim oldNode = GenerateGreenOperatorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPropertyStatementVisitor()
            Dim oldNode = GenerateGreenPropertyStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetAccessorStatementVisitor()
            Dim oldNode = GenerateGreenGetAccessorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSetAccessorStatementVisitor()
            Dim oldNode = GenerateGreenSetAccessorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerAccessorStatementVisitor()
            Dim oldNode = GenerateGreenAddHandlerAccessorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerAccessorStatementVisitor()
            Dim oldNode = GenerateGreenRemoveHandlerAccessorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventAccessorStatementVisitor()
            Dim oldNode = GenerateGreenRaiseEventAccessorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenImplementsClauseVisitor()
            Dim oldNode = GenerateGreenImplementsClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenHandlesClauseVisitor()
            Dim oldNode = GenerateGreenHandlesClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenKeywordEventContainerVisitor()
            Dim oldNode = GenerateGreenKeywordEventContainer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithEventsEventContainerVisitor()
            Dim oldNode = GenerateGreenWithEventsEventContainer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithEventsPropertyEventContainerVisitor()
            Dim oldNode = GenerateGreenWithEventsPropertyEventContainer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenHandlesClauseItemVisitor()
            Dim oldNode = GenerateGreenHandlesClauseItem()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIncompleteMemberVisitor()
            Dim oldNode = GenerateGreenIncompleteMember()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFieldDeclarationVisitor()
            Dim oldNode = GenerateGreenFieldDeclaration()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenVariableDeclaratorVisitor()
            Dim oldNode = GenerateGreenVariableDeclarator()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleAsClauseVisitor()
            Dim oldNode = GenerateGreenSimpleAsClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAsNewClauseVisitor()
            Dim oldNode = GenerateGreenAsNewClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectMemberInitializerVisitor()
            Dim oldNode = GenerateGreenObjectMemberInitializer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectCollectionInitializerVisitor()
            Dim oldNode = GenerateGreenObjectCollectionInitializer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInferredFieldInitializerVisitor()
            Dim oldNode = GenerateGreenInferredFieldInitializer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamedFieldInitializerVisitor()
            Dim oldNode = GenerateGreenNamedFieldInitializer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEqualsValueVisitor()
            Dim oldNode = GenerateGreenEqualsValue()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenParameterVisitor()
            Dim oldNode = GenerateGreenParameter()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModifiedIdentifierVisitor()
            Dim oldNode = GenerateGreenModifiedIdentifier()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayRankSpecifierVisitor()
            Dim oldNode = GenerateGreenArrayRankSpecifier()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeListVisitor()
            Dim oldNode = GenerateGreenAttributeList()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeVisitor()
            Dim oldNode = GenerateGreenAttribute()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributeTargetVisitor()
            Dim oldNode = GenerateGreenAttributeTarget()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAttributesStatementVisitor()
            Dim oldNode = GenerateGreenAttributesStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExpressionStatementVisitor()
            Dim oldNode = GenerateGreenExpressionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPrintStatementVisitor()
            Dim oldNode = GenerateGreenPrintStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileBlockVisitor()
            Dim oldNode = GenerateGreenWhileBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUsingBlockVisitor()
            Dim oldNode = GenerateGreenUsingBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSyncLockBlockVisitor()
            Dim oldNode = GenerateGreenSyncLockBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithBlockVisitor()
            Dim oldNode = GenerateGreenWithBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLocalDeclarationStatementVisitor()
            Dim oldNode = GenerateGreenLocalDeclarationStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLabelStatementVisitor()
            Dim oldNode = GenerateGreenLabelStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGoToStatementVisitor()
            Dim oldNode = GenerateGreenGoToStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIdentifierLabelVisitor()
            Dim oldNode = GenerateGreenIdentifierLabel()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNumericLabelVisitor()
            Dim oldNode = GenerateGreenNumericLabel()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNextLabelVisitor()
            Dim oldNode = GenerateGreenNextLabel()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStopStatementVisitor()
            Dim oldNode = GenerateGreenStopStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndStatementVisitor()
            Dim oldNode = GenerateGreenEndStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitDoStatementVisitor()
            Dim oldNode = GenerateGreenExitDoStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitForStatementVisitor()
            Dim oldNode = GenerateGreenExitForStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitSubStatementVisitor()
            Dim oldNode = GenerateGreenExitSubStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitFunctionStatementVisitor()
            Dim oldNode = GenerateGreenExitFunctionStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitOperatorStatementVisitor()
            Dim oldNode = GenerateGreenExitOperatorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitPropertyStatementVisitor()
            Dim oldNode = GenerateGreenExitPropertyStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitTryStatementVisitor()
            Dim oldNode = GenerateGreenExitTryStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitSelectStatementVisitor()
            Dim oldNode = GenerateGreenExitSelectStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExitWhileStatementVisitor()
            Dim oldNode = GenerateGreenExitWhileStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueWhileStatementVisitor()
            Dim oldNode = GenerateGreenContinueWhileStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueDoStatementVisitor()
            Dim oldNode = GenerateGreenContinueDoStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenContinueForStatementVisitor()
            Dim oldNode = GenerateGreenContinueForStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReturnStatementVisitor()
            Dim oldNode = GenerateGreenReturnStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineIfStatementVisitor()
            Dim oldNode = GenerateGreenSingleLineIfStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineElseClauseVisitor()
            Dim oldNode = GenerateGreenSingleLineElseClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineIfBlockVisitor()
            Dim oldNode = GenerateGreenMultiLineIfBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIfStatementVisitor()
            Dim oldNode = GenerateGreenIfStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfBlockVisitor()
            Dim oldNode = GenerateGreenElseIfBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfStatementVisitor()
            Dim oldNode = GenerateGreenElseIfStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseBlockVisitor()
            Dim oldNode = GenerateGreenElseBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseStatementVisitor()
            Dim oldNode = GenerateGreenElseStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryBlockVisitor()
            Dim oldNode = GenerateGreenTryBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryStatementVisitor()
            Dim oldNode = GenerateGreenTryStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchBlockVisitor()
            Dim oldNode = GenerateGreenCatchBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchStatementVisitor()
            Dim oldNode = GenerateGreenCatchStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCatchFilterClauseVisitor()
            Dim oldNode = GenerateGreenCatchFilterClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFinallyBlockVisitor()
            Dim oldNode = GenerateGreenFinallyBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFinallyStatementVisitor()
            Dim oldNode = GenerateGreenFinallyStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenErrorStatementVisitor()
            Dim oldNode = GenerateGreenErrorStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToZeroStatementVisitor()
            Dim oldNode = GenerateGreenOnErrorGoToZeroStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToMinusOneStatementVisitor()
            Dim oldNode = GenerateGreenOnErrorGoToMinusOneStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorGoToLabelStatementVisitor()
            Dim oldNode = GenerateGreenOnErrorGoToLabelStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOnErrorResumeNextStatementVisitor()
            Dim oldNode = GenerateGreenOnErrorResumeNextStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeStatementVisitor()
            Dim oldNode = GenerateGreenResumeStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeLabelStatementVisitor()
            Dim oldNode = GenerateGreenResumeLabelStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenResumeNextStatementVisitor()
            Dim oldNode = GenerateGreenResumeNextStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectBlockVisitor()
            Dim oldNode = GenerateGreenSelectBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectStatementVisitor()
            Dim oldNode = GenerateGreenSelectStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseBlockVisitor()
            Dim oldNode = GenerateGreenCaseBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseElseBlockVisitor()
            Dim oldNode = GenerateGreenCaseElseBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseStatementVisitor()
            Dim oldNode = GenerateGreenCaseStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseElseStatementVisitor()
            Dim oldNode = GenerateGreenCaseElseStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseCaseClauseVisitor()
            Dim oldNode = GenerateGreenElseCaseClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleCaseClauseVisitor()
            Dim oldNode = GenerateGreenSimpleCaseClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRangeCaseClauseVisitor()
            Dim oldNode = GenerateGreenRangeCaseClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseEqualsClauseVisitor()
            Dim oldNode = GenerateGreenCaseEqualsClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseNotEqualsClauseVisitor()
            Dim oldNode = GenerateGreenCaseNotEqualsClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseLessThanClauseVisitor()
            Dim oldNode = GenerateGreenCaseLessThanClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseLessThanOrEqualClauseVisitor()
            Dim oldNode = GenerateGreenCaseLessThanOrEqualClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseGreaterThanOrEqualClauseVisitor()
            Dim oldNode = GenerateGreenCaseGreaterThanOrEqualClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCaseGreaterThanClauseVisitor()
            Dim oldNode = GenerateGreenCaseGreaterThanClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSyncLockStatementVisitor()
            Dim oldNode = GenerateGreenSyncLockStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleDoLoopBlockVisitor()
            Dim oldNode = GenerateGreenSimpleDoLoopBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoWhileLoopBlockVisitor()
            Dim oldNode = GenerateGreenDoWhileLoopBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoUntilLoopBlockVisitor()
            Dim oldNode = GenerateGreenDoUntilLoopBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoLoopWhileBlockVisitor()
            Dim oldNode = GenerateGreenDoLoopWhileBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoLoopUntilBlockVisitor()
            Dim oldNode = GenerateGreenDoLoopUntilBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleDoStatementVisitor()
            Dim oldNode = GenerateGreenSimpleDoStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoWhileStatementVisitor()
            Dim oldNode = GenerateGreenDoWhileStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDoUntilStatementVisitor()
            Dim oldNode = GenerateGreenDoUntilStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleLoopStatementVisitor()
            Dim oldNode = GenerateGreenSimpleLoopStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLoopWhileStatementVisitor()
            Dim oldNode = GenerateGreenLoopWhileStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLoopUntilStatementVisitor()
            Dim oldNode = GenerateGreenLoopUntilStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileClauseVisitor()
            Dim oldNode = GenerateGreenWhileClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUntilClauseVisitor()
            Dim oldNode = GenerateGreenUntilClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhileStatementVisitor()
            Dim oldNode = GenerateGreenWhileStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForBlockVisitor()
            Dim oldNode = GenerateGreenForBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForEachBlockVisitor()
            Dim oldNode = GenerateGreenForEachBlock()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForStatementVisitor()
            Dim oldNode = GenerateGreenForStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForStepClauseVisitor()
            Dim oldNode = GenerateGreenForStepClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenForEachStatementVisitor()
            Dim oldNode = GenerateGreenForEachStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNextStatementVisitor()
            Dim oldNode = GenerateGreenNextStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUsingStatementVisitor()
            Dim oldNode = GenerateGreenUsingStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenThrowStatementVisitor()
            Dim oldNode = GenerateGreenThrowStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenSimpleAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMidAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenMidAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenAddAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubtractAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenSubtractAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiplyAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenMultiplyAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDivideAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenDivideAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIntegerDivideAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenIntegerDivideAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExponentiateAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenExponentiateAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLeftShiftAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenLeftShiftAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRightShiftAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenRightShiftAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConcatenateAssignmentStatementVisitor()
            Dim oldNode = GenerateGreenConcatenateAssignmentStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMidExpressionVisitor()
            Dim oldNode = GenerateGreenMidExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCallStatementVisitor()
            Dim oldNode = GenerateGreenCallStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddHandlerStatementVisitor()
            Dim oldNode = GenerateGreenAddHandlerStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRemoveHandlerStatementVisitor()
            Dim oldNode = GenerateGreenRemoveHandlerStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRaiseEventStatementVisitor()
            Dim oldNode = GenerateGreenRaiseEventStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWithStatementVisitor()
            Dim oldNode = GenerateGreenWithStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReDimStatementVisitor()
            Dim oldNode = GenerateGreenReDimStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReDimPreserveStatementVisitor()
            Dim oldNode = GenerateGreenReDimPreserveStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRedimClauseVisitor()
            Dim oldNode = GenerateGreenRedimClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEraseStatementVisitor()
            Dim oldNode = GenerateGreenEraseStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCharacterLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenCharacterLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTrueLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenTrueLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFalseLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenFalseLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNumericLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenNumericLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDateLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenDateLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenStringLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenStringLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNothingLiteralExpressionVisitor()
            Dim oldNode = GenerateGreenNothingLiteralExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenParenthesizedExpressionVisitor()
            Dim oldNode = GenerateGreenParenthesizedExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTupleExpressionVisitor()
            Dim oldNode = GenerateGreenTupleExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTupleTypeVisitor()
            Dim oldNode = GenerateGreenTupleType()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypedTupleElementVisitor()
            Dim oldNode = GenerateGreenTypedTupleElement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNamedTupleElementVisitor()
            Dim oldNode = GenerateGreenNamedTupleElement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMeExpressionVisitor()
            Dim oldNode = GenerateGreenMeExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMyBaseExpressionVisitor()
            Dim oldNode = GenerateGreenMyBaseExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMyClassExpressionVisitor()
            Dim oldNode = GenerateGreenMyClassExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetTypeExpressionVisitor()
            Dim oldNode = GenerateGreenGetTypeExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeOfIsExpressionVisitor()
            Dim oldNode = GenerateGreenTypeOfIsExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeOfIsNotExpressionVisitor()
            Dim oldNode = GenerateGreenTypeOfIsNotExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGetXmlNamespaceExpressionVisitor()
            Dim oldNode = GenerateGreenGetXmlNamespaceExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleMemberAccessExpressionVisitor()
            Dim oldNode = GenerateGreenSimpleMemberAccessExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDictionaryAccessExpressionVisitor()
            Dim oldNode = GenerateGreenDictionaryAccessExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementAccessExpressionVisitor()
            Dim oldNode = GenerateGreenXmlElementAccessExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDescendantAccessExpressionVisitor()
            Dim oldNode = GenerateGreenXmlDescendantAccessExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlAttributeAccessExpressionVisitor()
            Dim oldNode = GenerateGreenXmlAttributeAccessExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInvocationExpressionVisitor()
            Dim oldNode = GenerateGreenInvocationExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenObjectCreationExpressionVisitor()
            Dim oldNode = GenerateGreenObjectCreationExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAnonymousObjectCreationExpressionVisitor()
            Dim oldNode = GenerateGreenAnonymousObjectCreationExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayCreationExpressionVisitor()
            Dim oldNode = GenerateGreenArrayCreationExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCollectionInitializerVisitor()
            Dim oldNode = GenerateGreenCollectionInitializer()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCTypeExpressionVisitor()
            Dim oldNode = GenerateGreenCTypeExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDirectCastExpressionVisitor()
            Dim oldNode = GenerateGreenDirectCastExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTryCastExpressionVisitor()
            Dim oldNode = GenerateGreenTryCastExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPredefinedCastExpressionVisitor()
            Dim oldNode = GenerateGreenPredefinedCastExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddExpressionVisitor()
            Dim oldNode = GenerateGreenAddExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubtractExpressionVisitor()
            Dim oldNode = GenerateGreenSubtractExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiplyExpressionVisitor()
            Dim oldNode = GenerateGreenMultiplyExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDivideExpressionVisitor()
            Dim oldNode = GenerateGreenDivideExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIntegerDivideExpressionVisitor()
            Dim oldNode = GenerateGreenIntegerDivideExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExponentiateExpressionVisitor()
            Dim oldNode = GenerateGreenExponentiateExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLeftShiftExpressionVisitor()
            Dim oldNode = GenerateGreenLeftShiftExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRightShiftExpressionVisitor()
            Dim oldNode = GenerateGreenRightShiftExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConcatenateExpressionVisitor()
            Dim oldNode = GenerateGreenConcatenateExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenModuloExpressionVisitor()
            Dim oldNode = GenerateGreenModuloExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEqualsExpressionVisitor()
            Dim oldNode = GenerateGreenEqualsExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNotEqualsExpressionVisitor()
            Dim oldNode = GenerateGreenNotEqualsExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLessThanExpressionVisitor()
            Dim oldNode = GenerateGreenLessThanExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLessThanOrEqualExpressionVisitor()
            Dim oldNode = GenerateGreenLessThanOrEqualExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGreaterThanOrEqualExpressionVisitor()
            Dim oldNode = GenerateGreenGreaterThanOrEqualExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGreaterThanExpressionVisitor()
            Dim oldNode = GenerateGreenGreaterThanExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIsExpressionVisitor()
            Dim oldNode = GenerateGreenIsExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIsNotExpressionVisitor()
            Dim oldNode = GenerateGreenIsNotExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLikeExpressionVisitor()
            Dim oldNode = GenerateGreenLikeExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrExpressionVisitor()
            Dim oldNode = GenerateGreenOrExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExclusiveOrExpressionVisitor()
            Dim oldNode = GenerateGreenExclusiveOrExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAndExpressionVisitor()
            Dim oldNode = GenerateGreenAndExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrElseExpressionVisitor()
            Dim oldNode = GenerateGreenOrElseExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAndAlsoExpressionVisitor()
            Dim oldNode = GenerateGreenAndAlsoExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUnaryPlusExpressionVisitor()
            Dim oldNode = GenerateGreenUnaryPlusExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenUnaryMinusExpressionVisitor()
            Dim oldNode = GenerateGreenUnaryMinusExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNotExpressionVisitor()
            Dim oldNode = GenerateGreenNotExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAddressOfExpressionVisitor()
            Dim oldNode = GenerateGreenAddressOfExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenBinaryConditionalExpressionVisitor()
            Dim oldNode = GenerateGreenBinaryConditionalExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTernaryConditionalExpressionVisitor()
            Dim oldNode = GenerateGreenTernaryConditionalExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineFunctionLambdaExpressionVisitor()
            Dim oldNode = GenerateGreenSingleLineFunctionLambdaExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSingleLineSubLambdaExpressionVisitor()
            Dim oldNode = GenerateGreenSingleLineSubLambdaExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineFunctionLambdaExpressionVisitor()
            Dim oldNode = GenerateGreenMultiLineFunctionLambdaExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenMultiLineSubLambdaExpressionVisitor()
            Dim oldNode = GenerateGreenMultiLineSubLambdaExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSubLambdaHeaderVisitor()
            Dim oldNode = GenerateGreenSubLambdaHeader()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionLambdaHeaderVisitor()
            Dim oldNode = GenerateGreenFunctionLambdaHeader()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArgumentListVisitor()
            Dim oldNode = GenerateGreenArgumentList()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOmittedArgumentVisitor()
            Dim oldNode = GenerateGreenOmittedArgument()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleArgumentVisitor()
            Dim oldNode = GenerateGreenSimpleArgument()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNameColonEqualsVisitor()
            Dim oldNode = GenerateGreenNameColonEquals()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRangeArgumentVisitor()
            Dim oldNode = GenerateGreenRangeArgument()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenQueryExpressionVisitor()
            Dim oldNode = GenerateGreenQueryExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCollectionRangeVariableVisitor()
            Dim oldNode = GenerateGreenCollectionRangeVariable()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExpressionRangeVariableVisitor()
            Dim oldNode = GenerateGreenExpressionRangeVariable()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAggregationRangeVariableVisitor()
            Dim oldNode = GenerateGreenAggregationRangeVariable()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenVariableNameEqualsVisitor()
            Dim oldNode = GenerateGreenVariableNameEquals()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFunctionAggregationVisitor()
            Dim oldNode = GenerateGreenFunctionAggregation()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupAggregationVisitor()
            Dim oldNode = GenerateGreenGroupAggregation()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenFromClauseVisitor()
            Dim oldNode = GenerateGreenFromClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenLetClauseVisitor()
            Dim oldNode = GenerateGreenLetClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAggregateClauseVisitor()
            Dim oldNode = GenerateGreenAggregateClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDistinctClauseVisitor()
            Dim oldNode = GenerateGreenDistinctClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenWhereClauseVisitor()
            Dim oldNode = GenerateGreenWhereClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkipWhileClauseVisitor()
            Dim oldNode = GenerateGreenSkipWhileClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTakeWhileClauseVisitor()
            Dim oldNode = GenerateGreenTakeWhileClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkipClauseVisitor()
            Dim oldNode = GenerateGreenSkipClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTakeClauseVisitor()
            Dim oldNode = GenerateGreenTakeClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupByClauseVisitor()
            Dim oldNode = GenerateGreenGroupByClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenJoinConditionVisitor()
            Dim oldNode = GenerateGreenJoinCondition()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSimpleJoinClauseVisitor()
            Dim oldNode = GenerateGreenSimpleJoinClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGroupJoinClauseVisitor()
            Dim oldNode = GenerateGreenGroupJoinClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenOrderByClauseVisitor()
            Dim oldNode = GenerateGreenOrderByClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAscendingOrderingVisitor()
            Dim oldNode = GenerateGreenAscendingOrdering()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDescendingOrderingVisitor()
            Dim oldNode = GenerateGreenDescendingOrdering()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSelectClauseVisitor()
            Dim oldNode = GenerateGreenSelectClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDocumentVisitor()
            Dim oldNode = GenerateGreenXmlDocument()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDeclarationVisitor()
            Dim oldNode = GenerateGreenXmlDeclaration()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlDeclarationOptionVisitor()
            Dim oldNode = GenerateGreenXmlDeclarationOption()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementVisitor()
            Dim oldNode = GenerateGreenXmlElement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlTextVisitor()
            Dim oldNode = GenerateGreenXmlText()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementStartTagVisitor()
            Dim oldNode = GenerateGreenXmlElementStartTag()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlElementEndTagVisitor()
            Dim oldNode = GenerateGreenXmlElementEndTag()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEmptyElementVisitor()
            Dim oldNode = GenerateGreenXmlEmptyElement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlAttributeVisitor()
            Dim oldNode = GenerateGreenXmlAttribute()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlStringVisitor()
            Dim oldNode = GenerateGreenXmlString()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlPrefixNameVisitor()
            Dim oldNode = GenerateGreenXmlPrefixName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNameVisitor()
            Dim oldNode = GenerateGreenXmlName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlBracketedNameVisitor()
            Dim oldNode = GenerateGreenXmlBracketedName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlPrefixVisitor()
            Dim oldNode = GenerateGreenXmlPrefix()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCommentVisitor()
            Dim oldNode = GenerateGreenXmlComment()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlProcessingInstructionVisitor()
            Dim oldNode = GenerateGreenXmlProcessingInstruction()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCDataSectionVisitor()
            Dim oldNode = GenerateGreenXmlCDataSection()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlEmbeddedExpressionVisitor()
            Dim oldNode = GenerateGreenXmlEmbeddedExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenArrayTypeVisitor()
            Dim oldNode = GenerateGreenArrayType()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNullableTypeVisitor()
            Dim oldNode = GenerateGreenNullableType()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenPredefinedTypeVisitor()
            Dim oldNode = GenerateGreenPredefinedType()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIdentifierNameVisitor()
            Dim oldNode = GenerateGreenIdentifierName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGenericNameVisitor()
            Dim oldNode = GenerateGreenGenericName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenQualifiedNameVisitor()
            Dim oldNode = GenerateGreenQualifiedName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenGlobalNameVisitor()
            Dim oldNode = GenerateGreenGlobalName()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenTypeArgumentListVisitor()
            Dim oldNode = GenerateGreenTypeArgumentList()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefReferenceVisitor()
            Dim oldNode = GenerateGreenCrefReference()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefSignatureVisitor()
            Dim oldNode = GenerateGreenCrefSignature()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefSignaturePartVisitor()
            Dim oldNode = GenerateGreenCrefSignaturePart()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenCrefOperatorReferenceVisitor()
            Dim oldNode = GenerateGreenCrefOperatorReference()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenQualifiedCrefOperatorReferenceVisitor()
            Dim oldNode = GenerateGreenQualifiedCrefOperatorReference()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenYieldStatementVisitor()
            Dim oldNode = GenerateGreenYieldStatement()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenAwaitExpressionVisitor()
            Dim oldNode = GenerateGreenAwaitExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenSkippedTokensTriviaVisitor()
            Dim oldNode = GenerateGreenSkippedTokensTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDocumentationCommentTriviaVisitor()
            Dim oldNode = GenerateGreenDocumentationCommentTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlCrefAttributeVisitor()
            Dim oldNode = GenerateGreenXmlCrefAttribute()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenXmlNameAttributeVisitor()
            Dim oldNode = GenerateGreenXmlNameAttribute()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConditionalAccessExpressionVisitor()
            Dim oldNode = GenerateGreenConditionalAccessExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenNameOfExpressionVisitor()
            Dim oldNode = GenerateGreenNameOfExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringExpressionVisitor()
            Dim oldNode = GenerateGreenInterpolatedStringExpression()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolatedStringTextVisitor()
            Dim oldNode = GenerateGreenInterpolatedStringText()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationVisitor()
            Dim oldNode = GenerateGreenInterpolation()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationAlignmentClauseVisitor()
            Dim oldNode = GenerateGreenInterpolationAlignmentClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenInterpolationFormatClauseVisitor()
            Dim oldNode = GenerateGreenInterpolationFormatClause()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenConstDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenConstDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenIfDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenIfDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseIfDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenElseIfDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenElseDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenElseDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndIfDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenEndIfDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenRegionDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenRegionDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEndRegionDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenEndRegionDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenExternalChecksumDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenExternalChecksumDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenEnableWarningDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenEnableWarningDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenDisableWarningDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenDisableWarningDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenReferenceDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenReferenceDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
        <Fact>
        Public Sub TestGreenBadDirectiveTriviaVisitor()
            Dim oldNode = GenerateGreenBadDirectiveTrivia()
            Dim visitor = New GreenNodeVisitor()
            visitor.Visit(oldNode)
        End Sub
 
#end region
 
#region "Red Factory Calls"
        Private Shared Function GenerateRedEmptyStatement() As EmptyStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxKind.EmptyToken))
        End Function
 
        Private Shared Function GenerateRedEndIfStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndIfStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.IfKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndIfStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndIfStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndIfStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.IfKeyword))
        End Function
 
        Private Shared Function GenerateRedEndUsingStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndUsingStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.UsingKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndUsingStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndUsingStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndUsingStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.UsingKeyword))
        End Function
 
        Private Shared Function GenerateRedEndWithStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndWithStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WithKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndWithStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndWithStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndWithStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.WithKeyword))
        End Function
 
        Private Shared Function GenerateRedEndSelectStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndSelectStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SelectKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSelectStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSelectStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndSelectStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.SelectKeyword))
        End Function
 
        Private Shared Function GenerateRedEndStructureStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndStructureStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.StructureKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndStructureStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndStructureStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndStructureStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.StructureKeyword))
        End Function
 
        Private Shared Function GenerateRedEndEnumStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndEnumStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EnumKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndEnumStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndEnumStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndEnumStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.EnumKeyword))
        End Function
 
        Private Shared Function GenerateRedEndInterfaceStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndInterfaceStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndInterfaceStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndInterfaceStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndInterfaceStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword))
        End Function
 
        Private Shared Function GenerateRedEndClassStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndClassStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ClassKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndClassStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndClassStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndClassStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ClassKeyword))
        End Function
 
        Private Shared Function GenerateRedEndModuleStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndModuleStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ModuleKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndModuleStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndModuleStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndModuleStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ModuleKeyword))
        End Function
 
        Private Shared Function GenerateRedEndNamespaceStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndNamespaceStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndNamespaceStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndNamespaceStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndNamespaceStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword))
        End Function
 
        Private Shared Function GenerateRedEndSubStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndSubStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSubStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSubStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndSubStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword))
        End Function
 
        Private Shared Function GenerateRedEndFunctionStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndFunctionStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndFunctionStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndFunctionStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndFunctionStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword))
        End Function
 
        Private Shared Function GenerateRedEndGetStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndGetStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.GetKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndGetStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndGetStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndGetStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.GetKeyword))
        End Function
 
        Private Shared Function GenerateRedEndSetStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndSetStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SetKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSetStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSetStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndSetStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.SetKeyword))
        End Function
 
        Private Shared Function GenerateRedEndPropertyStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndPropertyStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.PropertyKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndPropertyStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndPropertyStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndPropertyStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.PropertyKeyword))
        End Function
 
        Private Shared Function GenerateRedEndOperatorStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndOperatorStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndOperatorStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndOperatorStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndOperatorStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword))
        End Function
 
        Private Shared Function GenerateRedEndEventStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndEventStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EventKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndEventStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndEventStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndEventStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.EventKeyword))
        End Function
 
        Private Shared Function GenerateRedEndAddHandlerStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndAddHandlerStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndAddHandlerStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndAddHandlerStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndAddHandlerStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword))
        End Function
 
        Private Shared Function GenerateRedEndRemoveHandlerStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndRemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndRemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndRemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndRemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword))
        End Function
 
        Private Shared Function GenerateRedEndRaiseEventStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndRaiseEventStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.RaiseEventKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndRaiseEventStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndRaiseEventStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndRaiseEventStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.RaiseEventKeyword))
        End Function
 
        Private Shared Function GenerateRedEndWhileStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndWhileStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndWhileStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndWhileStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndWhileStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword))
        End Function
 
        Private Shared Function GenerateRedEndTryStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndTryStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.TryKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndTryStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndTryStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndTryStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.TryKeyword))
        End Function
 
        Private Shared Function GenerateRedEndSyncLockStatement() As EndBlockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndSyncLockStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SyncLockKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSyncLockStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndSyncLockStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndSyncLockStatement(SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.SyncLockKeyword))
        End Function
 
        Private Shared Function GenerateRedCompilationUnit() As CompilationUnitSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CompilationUnit(Nothing, Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CompilationUnit(Nothing, Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.EndOfFileToken))
        End Function
 
        Private Shared Function GenerateRedOptionStatement() As OptionStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OptionStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ExplicitKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OptionStatement(SyntaxFactory.Token(SyntaxKind.OptionKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OptionStatement(SyntaxFactory.Token(SyntaxKind.OptionKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OptionStatement(SyntaxFactory.Token(SyntaxKind.OptionKeyword), SyntaxFactory.Token(SyntaxKind.ExplicitKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedImportsStatement() As ImportsStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ImportsStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ImportsStatement(SyntaxFactory.Token(SyntaxKind.ImportsKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedSimpleImportsClause() As SimpleImportsClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleImportsClause(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleImportsClause(Nothing, GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedImportAliasClause() As ImportAliasClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ImportAliasClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EqualsToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ImportAliasClause(GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ImportAliasClause(GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken))
        End Function
 
        Private Shared Function GenerateRedXmlNamespaceImportsClause() As XmlNamespaceImportsClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlNamespaceImportsClause(SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNamespaceImportsClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlAttribute(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNamespaceImportsClause(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlAttribute(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlNamespaceImportsClause(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlAttribute(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedNamespaceBlock() As NamespaceBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NamespaceBlock(Nothing, Nothing, GenerateRedEndNamespaceStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NamespaceBlock(GenerateRedNamespaceStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NamespaceBlock(GenerateRedNamespaceStatement(), Nothing, GenerateRedEndNamespaceStatement())
        End Function
 
        Private Shared Function GenerateRedNamespaceStatement() As NamespaceStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NamespaceStatement(SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NamespaceStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NamespaceStatement(SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedModuleBlock() As ModuleBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ModuleBlock(Nothing, Nothing, Nothing, Nothing, GenerateRedEndModuleStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ModuleBlock(GenerateRedModuleStatement(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ModuleBlock(GenerateRedModuleStatement(), Nothing, Nothing, Nothing, GenerateRedEndModuleStatement())
        End Function
 
        Private Shared Function GenerateRedStructureBlock() As StructureBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.StructureBlock(Nothing, Nothing, Nothing, Nothing, GenerateRedEndStructureStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.StructureBlock(GenerateRedStructureStatement(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.StructureBlock(GenerateRedStructureStatement(), Nothing, Nothing, Nothing, GenerateRedEndStructureStatement())
        End Function
 
        Private Shared Function GenerateRedInterfaceBlock() As InterfaceBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InterfaceBlock(Nothing, Nothing, Nothing, Nothing, GenerateRedEndInterfaceStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.InterfaceBlock(GenerateRedInterfaceStatement(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InterfaceBlock(GenerateRedInterfaceStatement(), Nothing, Nothing, Nothing, GenerateRedEndInterfaceStatement())
        End Function
 
        Private Shared Function GenerateRedClassBlock() As ClassBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ClassBlock(Nothing, Nothing, Nothing, Nothing, GenerateRedEndClassStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ClassBlock(GenerateRedClassStatement(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ClassBlock(GenerateRedClassStatement(), Nothing, Nothing, Nothing, GenerateRedEndClassStatement())
        End Function
 
        Private Shared Function GenerateRedEnumBlock() As EnumBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EnumBlock(Nothing, Nothing, GenerateRedEndEnumStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EnumBlock(GenerateRedEnumStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EnumBlock(GenerateRedEnumStatement(), Nothing, GenerateRedEndEnumStatement())
        End Function
 
        Private Shared Function GenerateRedInheritsStatement() As InheritsStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InheritsStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of TypeSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InheritsStatement(SyntaxFactory.Token(SyntaxKind.InheritsKeyword), New SeparatedSyntaxList(Of TypeSyntax)())
        End Function
 
        Private Shared Function GenerateRedImplementsStatement() As ImplementsStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ImplementsStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of TypeSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ImplementsStatement(SyntaxFactory.Token(SyntaxKind.ImplementsKeyword), New SeparatedSyntaxList(Of TypeSyntax)())
        End Function
 
        Private Shared Function GenerateRedModuleStatement() As ModuleStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ModuleStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ModuleStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ModuleKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ModuleStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ModuleKeyword), GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedStructureStatement() As StructureStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.StructureStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.StructureStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.StructureKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.StructureStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.StructureKeyword), GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedInterfaceStatement() As InterfaceStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InterfaceStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.InterfaceStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InterfaceStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedClassStatement() As ClassStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ClassStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ClassStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ClassKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ClassStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ClassKeyword), GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedEnumStatement() As EnumStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EnumStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EnumStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.EnumKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EnumStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.EnumKeyword), GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedTypeParameterList() As TypeParameterListSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OfKeyword), New SeparatedSyntaxList(Of TypeParameterSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of TypeParameterSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.OfKeyword), New SeparatedSyntaxList(Of TypeParameterSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.OfKeyword), New SeparatedSyntaxList(Of TypeParameterSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTypeParameter() As TypeParameterSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeParameter(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeParameter(Nothing, GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedTypeParameterSingleConstraintClause() As TypeParameterSingleConstraintClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeParameterSingleConstraintClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeParameterSingleConstraintClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedNewConstraint())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeParameterSingleConstraintClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), GenerateRedNewConstraint())
        End Function
 
        Private Shared Function GenerateRedTypeParameterMultipleConstraintClause() As TypeParameterMultipleConstraintClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeParameterMultipleConstraintClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), New SeparatedSyntaxList(Of ConstraintSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeParameterMultipleConstraintClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of ConstraintSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeParameterMultipleConstraintClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), New SeparatedSyntaxList(Of ConstraintSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeParameterMultipleConstraintClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), New SeparatedSyntaxList(Of ConstraintSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
        End Function
 
        Private Shared Function GenerateRedNewConstraint() As SpecialConstraintSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NewConstraint(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NewConstraint(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NewConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword))
        End Function
 
        Private Shared Function GenerateRedClassConstraint() As SpecialConstraintSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ClassConstraint(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ClassConstraint(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ClassConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword))
        End Function
 
        Private Shared Function GenerateRedStructureConstraint() As SpecialConstraintSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.StructureConstraint(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.StructureConstraint(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.StructureConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword))
        End Function
 
        Private Shared Function GenerateRedTypeConstraint() As TypeConstraintSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeConstraint(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeConstraint(GenerateRedTupleType())
        End Function
 
        Private Shared Function GenerateRedEnumMemberDeclaration() As EnumMemberDeclarationSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EnumMemberDeclaration(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EnumMemberDeclaration(Nothing, GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedSubBlock() As MethodBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SubBlock(Nothing, Nothing, GenerateRedEndSubStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubBlock(GenerateRedSubStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SubBlock(GenerateRedSubStatement(), Nothing, GenerateRedEndSubStatement())
        End Function
 
        Private Shared Function GenerateRedFunctionBlock() As MethodBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FunctionBlock(Nothing, Nothing, GenerateRedEndFunctionStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.FunctionBlock(GenerateRedFunctionStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FunctionBlock(GenerateRedFunctionStatement(), Nothing, GenerateRedEndFunctionStatement())
        End Function
 
        Private Shared Function GenerateRedConstructorBlock() As ConstructorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ConstructorBlock(Nothing, Nothing, GenerateRedEndSubStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConstructorBlock(GenerateRedSubNewStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ConstructorBlock(GenerateRedSubNewStatement(), Nothing, GenerateRedEndSubStatement())
        End Function
 
        Private Shared Function GenerateRedOperatorBlock() As OperatorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OperatorBlock(Nothing, Nothing, GenerateRedEndOperatorStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OperatorBlock(GenerateRedOperatorStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OperatorBlock(GenerateRedOperatorStatement(), Nothing, GenerateRedEndOperatorStatement())
        End Function
 
        Private Shared Function GenerateRedGetAccessorBlock() As AccessorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GetAccessorBlock(Nothing, Nothing, GenerateRedEndGetStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetAccessorBlock(GenerateRedGetAccessorStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GetAccessorBlock(GenerateRedGetAccessorStatement(), Nothing, GenerateRedEndGetStatement())
        End Function
 
        Private Shared Function GenerateRedSetAccessorBlock() As AccessorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SetAccessorBlock(Nothing, Nothing, GenerateRedEndSetStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SetAccessorBlock(GenerateRedSetAccessorStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SetAccessorBlock(GenerateRedSetAccessorStatement(), Nothing, GenerateRedEndSetStatement())
        End Function
 
        Private Shared Function GenerateRedAddHandlerAccessorBlock() As AccessorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AddHandlerAccessorBlock(Nothing, Nothing, GenerateRedEndAddHandlerStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddHandlerAccessorBlock(GenerateRedAddHandlerAccessorStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AddHandlerAccessorBlock(GenerateRedAddHandlerAccessorStatement(), Nothing, GenerateRedEndAddHandlerStatement())
        End Function
 
        Private Shared Function GenerateRedRemoveHandlerAccessorBlock() As AccessorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RemoveHandlerAccessorBlock(Nothing, Nothing, GenerateRedEndRemoveHandlerStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RemoveHandlerAccessorBlock(GenerateRedRemoveHandlerAccessorStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RemoveHandlerAccessorBlock(GenerateRedRemoveHandlerAccessorStatement(), Nothing, GenerateRedEndRemoveHandlerStatement())
        End Function
 
        Private Shared Function GenerateRedRaiseEventAccessorBlock() As AccessorBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RaiseEventAccessorBlock(Nothing, Nothing, GenerateRedEndRaiseEventStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RaiseEventAccessorBlock(GenerateRedRaiseEventAccessorStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RaiseEventAccessorBlock(GenerateRedRaiseEventAccessorStatement(), Nothing, GenerateRedEndRaiseEventStatement())
        End Function
 
        Private Shared Function GenerateRedPropertyBlock() As PropertyBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.PropertyBlock(Nothing, SyntaxFactory.SingletonList(Of AccessorBlockSyntax)(GenerateRedGetAccessorBlock()), GenerateRedEndPropertyStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PropertyBlock(GenerateRedPropertyStatement(), SyntaxFactory.SingletonList(Of AccessorBlockSyntax)(GenerateRedGetAccessorBlock()), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.PropertyBlock(GenerateRedPropertyStatement(), SyntaxFactory.SingletonList(Of AccessorBlockSyntax)(GenerateRedGetAccessorBlock()), GenerateRedEndPropertyStatement())
        End Function
 
        Private Shared Function GenerateRedEventBlock() As EventBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EventBlock(Nothing, SyntaxFactory.SingletonList(Of AccessorBlockSyntax)(GenerateRedAddHandlerAccessorBlock()), GenerateRedEndEventStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EventBlock(GenerateRedEventStatement(), SyntaxFactory.SingletonList(Of AccessorBlockSyntax)(GenerateRedAddHandlerAccessorBlock()), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EventBlock(GenerateRedEventStatement(), SyntaxFactory.SingletonList(Of AccessorBlockSyntax)(GenerateRedAddHandlerAccessorBlock()), GenerateRedEndEventStatement())
        End Function
 
        Private Shared Function GenerateRedParameterList() As ParameterListSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedSubStatement() As MethodStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedFunctionStatement() As MethodStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.FunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.FunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedSubNewStatement() As SubNewStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SubNewStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubNewStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SubNewStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedDeclareSubStatement() As DeclareStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DeclareSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedDeclareFunctionStatement() As DeclareStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DeclareFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DeclareKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.LibKeyword), GenerateRedCharacterLiteralExpression(), Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedDelegateSubStatement() As DelegateStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DelegateSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DelegateSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DelegateSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DelegateSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DelegateSubStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedDelegateFunctionStatement() As DelegateStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DelegateFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DelegateFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DelegateFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DelegateFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DelegateFunctionStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedEventStatement() As EventStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EventStatement(Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EventStatement(Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.EventKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EventStatement(Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedOperatorStatement() As OperatorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OperatorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.CTypeKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OperatorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OperatorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OperatorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.CTypeKeyword), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedPropertyStatement() As PropertyStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.PropertyStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PropertyStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.PropertyKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.PropertyStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.PropertyKeyword), GenerateRedIdentifierToken(), Nothing, Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedGetAccessorStatement() As AccessorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GetAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GetAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.GetKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedSetAccessorStatement() As AccessorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SetAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SetAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SetAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SetKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedAddHandlerAccessorStatement() As AccessorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AddHandlerAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddHandlerAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AddHandlerAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedRemoveHandlerAccessorStatement() As AccessorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RemoveHandlerAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RemoveHandlerAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RemoveHandlerAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedRaiseEventAccessorStatement() As AccessorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RaiseEventAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RaiseEventAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RaiseEventAccessorStatement(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.RaiseEventKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedImplementsClause() As ImplementsClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ImplementsClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of QualifiedNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ImplementsClause(SyntaxFactory.Token(SyntaxKind.ImplementsKeyword), New SeparatedSyntaxList(Of QualifiedNameSyntax)())
        End Function
 
        Private Shared Function GenerateRedHandlesClause() As HandlesClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.HandlesClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of HandlesClauseItemSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.HandlesClause(SyntaxFactory.Token(SyntaxKind.HandlesKeyword), New SeparatedSyntaxList(Of HandlesClauseItemSyntax)())
        End Function
 
        Private Shared Function GenerateRedKeywordEventContainer() As KeywordEventContainerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.KeywordEventContainer(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.KeywordEventContainer(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.KeywordEventContainer(SyntaxFactory.Token(SyntaxKind.MyBaseKeyword))
        End Function
 
        Private Shared Function GenerateRedWithEventsEventContainer() As WithEventsEventContainerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WithEventsEventContainer(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WithEventsEventContainer(GenerateRedIdentifierToken())
        End Function
 
        Private Shared Function GenerateRedWithEventsPropertyEventContainer() As WithEventsPropertyEventContainerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WithEventsPropertyEventContainer(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WithEventsPropertyEventContainer(GenerateRedWithEventsEventContainer(), SyntaxFactory.Token(SyntaxKind.DotToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WithEventsPropertyEventContainer(GenerateRedWithEventsEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WithEventsPropertyEventContainer(GenerateRedWithEventsEventContainer(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedHandlesClauseItem() As HandlesClauseItemSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.HandlesClauseItem(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.HandlesClauseItem(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.DotToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.HandlesClauseItem(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.HandlesClauseItem(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedIncompleteMember() As IncompleteMemberSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.IncompleteMember(Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedFieldDeclaration() As FieldDeclarationSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.FieldDeclaration(Nothing, Nothing, New SeparatedSyntaxList(Of VariableDeclaratorSyntax)())
        End Function
 
        Private Shared Function GenerateRedVariableDeclarator() As VariableDeclaratorSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.VariableDeclarator(New SeparatedSyntaxList(Of ModifiedIdentifierSyntax)(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedSimpleAsClause() As SimpleAsClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleAsClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleAsClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleAsClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), Nothing, GenerateRedTupleType())
        End Function
 
        Private Shared Function GenerateRedAsNewClause() As AsNewClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AsNewClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AsNewClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedObjectCreationExpression())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AsNewClause(SyntaxFactory.Token(SyntaxKind.AsKeyword), GenerateRedObjectCreationExpression())
        End Function
 
        Private Shared Function GenerateRedObjectMemberInitializer() As ObjectMemberInitializerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ObjectMemberInitializer(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), New SeparatedSyntaxList(Of FieldInitializerSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ObjectMemberInitializer(SyntaxFactory.Token(SyntaxKind.WithKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of FieldInitializerSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ObjectMemberInitializer(SyntaxFactory.Token(SyntaxKind.WithKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), New SeparatedSyntaxList(Of FieldInitializerSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ObjectMemberInitializer(SyntaxFactory.Token(SyntaxKind.WithKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), New SeparatedSyntaxList(Of FieldInitializerSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
        End Function
 
        Private Shared Function GenerateRedObjectCollectionInitializer() As ObjectCollectionInitializerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ObjectCollectionInitializer(SyntaxFactory.Token(SyntaxKind.FromKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ObjectCollectionInitializer(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedCollectionInitializer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ObjectCollectionInitializer(SyntaxFactory.Token(SyntaxKind.FromKeyword), GenerateRedCollectionInitializer())
        End Function
 
        Private Shared Function GenerateRedInferredFieldInitializer() As InferredFieldInitializerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InferredFieldInitializer(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InferredFieldInitializer(Nothing, GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedNamedFieldInitializer() As NamedFieldInitializerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NamedFieldInitializer(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NamedFieldInitializer(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NamedFieldInitializer(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NamedFieldInitializer(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NamedFieldInitializer(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedEqualsValue() As EqualsValueSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EqualsValue(SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EqualsValue(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EqualsValue(SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedParameter() As ParameterSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.Parameter(Nothing, Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.Parameter(Nothing, Nothing, GenerateRedModifiedIdentifier(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedModifiedIdentifier() As ModifiedIdentifierSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ModifiedIdentifier(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ModifiedIdentifier(GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedArrayRankSpecifier() As ArrayRankSpecifierSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedAttributeList() As AttributeListSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedAttribute() As AttributeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.Attribute(Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.Attribute(Nothing, GenerateRedPredefinedType(), Nothing)
        End Function
 
        Private Shared Function GenerateRedAttributeTarget() As AttributeTargetSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AttributeTarget(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AttributeTarget(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AttributeTarget(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AttributeTarget(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken))
        End Function
 
        Private Shared Function GenerateRedAttributesStatement() As AttributesStatementSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.AttributesStatement(Nothing)
        End Function
 
        Private Shared Function GenerateRedExpressionStatement() As ExpressionStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExpressionStatement(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExpressionStatement(GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedPrintStatement() As PrintStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.PrintStatement(SyntaxFactory.Token(SyntaxKind.QuestionToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PrintStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.PrintStatement(SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedWhileBlock() As WhileBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WhileBlock(Nothing, Nothing, GenerateRedEndWhileStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WhileBlock(GenerateRedWhileStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WhileBlock(GenerateRedWhileStatement(), Nothing, GenerateRedEndWhileStatement())
        End Function
 
        Private Shared Function GenerateRedUsingBlock() As UsingBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.UsingBlock(Nothing, Nothing, GenerateRedEndUsingStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UsingBlock(GenerateRedUsingStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.UsingBlock(GenerateRedUsingStatement(), Nothing, GenerateRedEndUsingStatement())
        End Function
 
        Private Shared Function GenerateRedSyncLockBlock() As SyncLockBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SyncLockBlock(Nothing, Nothing, GenerateRedEndSyncLockStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SyncLockBlock(GenerateRedSyncLockStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SyncLockBlock(GenerateRedSyncLockStatement(), Nothing, GenerateRedEndSyncLockStatement())
        End Function
 
        Private Shared Function GenerateRedWithBlock() As WithBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WithBlock(Nothing, Nothing, GenerateRedEndWithStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WithBlock(GenerateRedWithStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WithBlock(GenerateRedWithStatement(), Nothing, GenerateRedEndWithStatement())
        End Function
 
        Private Shared Function GenerateRedLocalDeclarationStatement() As LocalDeclarationStatementSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.LocalDeclarationStatement(SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.StaticKeyword)), New SeparatedSyntaxList(Of VariableDeclaratorSyntax)())
        End Function
 
        Private Shared Function GenerateRedLabelStatement() As LabelStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LabelStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LabelStatement(GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LabelStatement(GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.ColonToken))
        End Function
 
        Private Shared Function GenerateRedGoToStatement() As GoToStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GoToStatement(SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GoToStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GoToStatement(SyntaxFactory.Token(SyntaxKind.GoToKeyword), GenerateRedIdentifierLabel())
        End Function
 
        Private Shared Function GenerateRedIdentifierLabel() As LabelSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IdentifierLabel(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IdentifierLabel(GenerateRedIdentifierToken())
        End Function
 
        Private Shared Function GenerateRedNumericLabel() As LabelSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NumericLabel(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NumericLabel(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedNextLabel() As LabelSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NextLabel(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NextLabel(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NextLabel(SyntaxFactory.Token(SyntaxKind.NextKeyword))
        End Function
 
        Private Shared Function GenerateRedStopStatement() As StopOrEndStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.StopStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.StopStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.StopStatement(SyntaxFactory.Token(SyntaxKind.StopKeyword))
        End Function
 
        Private Shared Function GenerateRedEndStatement() As StopOrEndStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndStatement(SyntaxFactory.Token(SyntaxKind.StopKeyword))
        End Function
 
        Private Shared Function GenerateRedExitDoStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitDoStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.DoKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitDoStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitDoStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitDoStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.DoKeyword))
        End Function
 
        Private Shared Function GenerateRedExitForStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitForStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ForKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitForStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitForStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitForStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ForKeyword))
        End Function
 
        Private Shared Function GenerateRedExitSubStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitSubStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitSubStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitSubStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitSubStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.SubKeyword))
        End Function
 
        Private Shared Function GenerateRedExitFunctionStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitFunctionStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitFunctionStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitFunctionStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitFunctionStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword))
        End Function
 
        Private Shared Function GenerateRedExitOperatorStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitOperatorStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitOperatorStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitOperatorStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitOperatorStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword))
        End Function
 
        Private Shared Function GenerateRedExitPropertyStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitPropertyStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.PropertyKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitPropertyStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitPropertyStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitPropertyStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.PropertyKeyword))
        End Function
 
        Private Shared Function GenerateRedExitTryStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitTryStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.TryKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitTryStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitTryStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitTryStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.TryKeyword))
        End Function
 
        Private Shared Function GenerateRedExitSelectStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitSelectStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.SelectKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitSelectStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitSelectStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitSelectStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.SelectKeyword))
        End Function
 
        Private Shared Function GenerateRedExitWhileStatement() As ExitStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExitWhileStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitWhileStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExitWhileStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExitWhileStatement(SyntaxFactory.Token(SyntaxKind.ExitKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword))
        End Function
 
        Private Shared Function GenerateRedContinueWhileStatement() As ContinueStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ContinueWhileStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ContinueWhileStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ContinueWhileStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ContinueWhileStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword))
        End Function
 
        Private Shared Function GenerateRedContinueDoStatement() As ContinueStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ContinueDoStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.DoKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ContinueDoStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ContinueDoStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ContinueDoStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.DoKeyword))
        End Function
 
        Private Shared Function GenerateRedContinueForStatement() As ContinueStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ContinueForStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ForKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ContinueForStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ContinueForStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ContinueForStatement(SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.ForKeyword))
        End Function
 
        Private Shared Function GenerateRedReturnStatement() As ReturnStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ReturnStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ReturnStatement(SyntaxFactory.Token(SyntaxKind.ReturnKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedSingleLineIfStatement() As SingleLineIfStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SingleLineIfStatement(SyntaxFactory.Token(SyntaxKind.IfKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ThenKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SingleLineIfStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ThenKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SingleLineIfStatement(SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SingleLineIfStatement(SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ThenKeyword), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedSingleLineElseClause() As SingleLineElseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SingleLineElseClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SingleLineElseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedMultiLineIfBlock() As MultiLineIfBlockSyntax
            return SyntaxFactory.MultiLineIfBlock(GenerateRedIfStatement(), Nothing, Nothing, Nothing, GenerateRedEndIfStatement())
        End Function
 
        Private Shared Function GenerateRedIfStatement() As IfStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IfStatement(SyntaxFactory.Token(SyntaxKind.IfKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IfStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IfStatement(SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedElseIfBlock() As ElseIfBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseIfBlock(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseIfBlock(GenerateRedElseIfStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedElseIfStatement() As ElseIfStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseIfStatement(SyntaxFactory.Token(SyntaxKind.ElseIfKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ElseIfStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseIfStatement(SyntaxFactory.Token(SyntaxKind.ElseIfKeyword), GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedElseBlock() As ElseBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseBlock(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseBlock(GenerateRedElseStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedElseStatement() As ElseStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseStatement(SyntaxFactory.Token(SyntaxKind.ElseKeyword))
        End Function
 
        Private Shared Function GenerateRedTryBlock() As TryBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TryBlock(Nothing, Nothing, Nothing, Nothing, GenerateRedEndTryStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryBlock(GenerateRedTryStatement(), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TryBlock(GenerateRedTryStatement(), Nothing, Nothing, Nothing, GenerateRedEndTryStatement())
        End Function
 
        Private Shared Function GenerateRedTryStatement() As TryStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TryStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TryStatement(SyntaxFactory.Token(SyntaxKind.TryKeyword))
        End Function
 
        Private Shared Function GenerateRedCatchBlock() As CatchBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CatchBlock(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CatchBlock(GenerateRedCatchStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedCatchStatement() As CatchStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CatchStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CatchStatement(SyntaxFactory.Token(SyntaxKind.CatchKeyword), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedCatchFilterClause() As CatchFilterClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedFinallyBlock() As FinallyBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FinallyBlock(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FinallyBlock(GenerateRedFinallyStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedFinallyStatement() As FinallyStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FinallyStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FinallyStatement(SyntaxFactory.Token(SyntaxKind.FinallyKeyword))
        End Function
 
        Private Shared Function GenerateRedErrorStatement() As ErrorStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ErrorStatement(SyntaxFactory.Token(SyntaxKind.ErrorKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ErrorStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ErrorStatement(SyntaxFactory.Token(SyntaxKind.ErrorKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedOnErrorGoToZeroStatement() As OnErrorGoToStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OnErrorGoToZeroStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToZeroStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToZeroStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToZeroStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OnErrorGoToZeroStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
        End Function
 
        Private Shared Function GenerateRedOnErrorGoToMinusOneStatement() As OnErrorGoToStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OnErrorGoToMinusOneStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToMinusOneStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToMinusOneStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToMinusOneStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OnErrorGoToMinusOneStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
        End Function
 
        Private Shared Function GenerateRedOnErrorGoToLabelStatement() As OnErrorGoToStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OnErrorGoToLabelStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToLabelStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToLabelStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorGoToLabelStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedIdentifierLabel())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OnErrorGoToLabelStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.GoToKeyword), Nothing, GenerateRedIdentifierLabel())
        End Function
 
        Private Shared Function GenerateRedOnErrorResumeNextStatement() As OnErrorResumeNextStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OnErrorResumeNextStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ResumeKeyword), SyntaxFactory.Token(SyntaxKind.NextKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorResumeNextStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ResumeKeyword), SyntaxFactory.Token(SyntaxKind.NextKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorResumeNextStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.NextKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OnErrorResumeNextStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ResumeKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OnErrorResumeNextStatement(SyntaxFactory.Token(SyntaxKind.OnKeyword), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.ResumeKeyword), SyntaxFactory.Token(SyntaxKind.NextKeyword))
        End Function
 
        Private Shared Function GenerateRedResumeStatement() As ResumeStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ResumeStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ResumeStatement(SyntaxFactory.Token(SyntaxKind.ResumeKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedResumeLabelStatement() As ResumeStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ResumeLabelStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ResumeLabelStatement(SyntaxFactory.Token(SyntaxKind.ResumeKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedResumeNextStatement() As ResumeStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ResumeNextStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ResumeNextStatement(SyntaxFactory.Token(SyntaxKind.ResumeKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedSelectBlock() As SelectBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SelectBlock(Nothing, Nothing, GenerateRedEndSelectStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SelectBlock(GenerateRedSelectStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SelectBlock(GenerateRedSelectStatement(), Nothing, GenerateRedEndSelectStatement())
        End Function
 
        Private Shared Function GenerateRedSelectStatement() As SelectStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SelectStatement(SyntaxFactory.Token(SyntaxKind.SelectKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SelectStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SelectStatement(SyntaxFactory.Token(SyntaxKind.SelectKeyword), Nothing, GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseBlock() As CaseBlockSyntax
            return SyntaxFactory.CaseBlock(GenerateRedCaseStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedCaseElseBlock() As CaseBlockSyntax
            return SyntaxFactory.CaseElseBlock(GenerateRedCaseStatement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedCaseStatement() As CaseStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CaseClauseSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseStatement(SyntaxFactory.Token(SyntaxKind.CaseKeyword), New SeparatedSyntaxList(Of CaseClauseSyntax)())
        End Function
 
        Private Shared Function GenerateRedCaseElseStatement() As CaseStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseElseStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CaseClauseSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseElseStatement(SyntaxFactory.Token(SyntaxKind.CaseKeyword), New SeparatedSyntaxList(Of CaseClauseSyntax)())
        End Function
 
        Private Shared Function GenerateRedElseCaseClause() As ElseCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseCaseClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseCaseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword))
        End Function
 
        Private Shared Function GenerateRedSimpleCaseClause() As SimpleCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleCaseClause(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleCaseClause(GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedRangeCaseClause() As RangeCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RangeCaseClause(Nothing, SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RangeCaseClause(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RangeCaseClause(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RangeCaseClause(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseEqualsClause() As RelationalCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseNotEqualsClause() As RelationalCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseNotEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanGreaterThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseNotEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseNotEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseNotEqualsClause(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanGreaterThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseLessThanClause() As RelationalCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseLessThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseLessThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseLessThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseLessThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseLessThanOrEqualClause() As RelationalCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseLessThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseLessThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseLessThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseLessThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseGreaterThanOrEqualClause() As RelationalCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseGreaterThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseGreaterThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseGreaterThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseGreaterThanOrEqualClause(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedCaseGreaterThanClause() As RelationalCaseClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CaseGreaterThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseGreaterThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CaseGreaterThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CaseGreaterThanClause(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSyncLockStatement() As SyncLockStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SyncLockStatement(SyntaxFactory.Token(SyntaxKind.SyncLockKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SyncLockStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SyncLockStatement(SyntaxFactory.Token(SyntaxKind.SyncLockKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSimpleDoLoopBlock() As DoLoopBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleDoLoopBlock(Nothing, Nothing, GenerateRedSimpleLoopStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleDoLoopBlock(GenerateRedSimpleDoStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleDoLoopBlock(GenerateRedSimpleDoStatement(), Nothing, GenerateRedSimpleLoopStatement())
        End Function
 
        Private Shared Function GenerateRedDoWhileLoopBlock() As DoLoopBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DoWhileLoopBlock(Nothing, Nothing, GenerateRedSimpleLoopStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DoWhileLoopBlock(GenerateRedDoWhileStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DoWhileLoopBlock(GenerateRedDoWhileStatement(), Nothing, GenerateRedSimpleLoopStatement())
        End Function
 
        Private Shared Function GenerateRedDoUntilLoopBlock() As DoLoopBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DoUntilLoopBlock(Nothing, Nothing, GenerateRedSimpleLoopStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DoUntilLoopBlock(GenerateRedDoUntilStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DoUntilLoopBlock(GenerateRedDoUntilStatement(), Nothing, GenerateRedSimpleLoopStatement())
        End Function
 
        Private Shared Function GenerateRedDoLoopWhileBlock() As DoLoopBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DoLoopWhileBlock(Nothing, Nothing, GenerateRedLoopWhileStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DoLoopWhileBlock(GenerateRedSimpleDoStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DoLoopWhileBlock(GenerateRedSimpleDoStatement(), Nothing, GenerateRedLoopWhileStatement())
        End Function
 
        Private Shared Function GenerateRedDoLoopUntilBlock() As DoLoopBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DoLoopUntilBlock(Nothing, Nothing, GenerateRedLoopUntilStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DoLoopUntilBlock(GenerateRedSimpleDoStatement(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DoLoopUntilBlock(GenerateRedSimpleDoStatement(), Nothing, GenerateRedLoopUntilStatement())
        End Function
 
        Private Shared Function GenerateRedSimpleDoStatement() As DoStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleDoStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleDoStatement(SyntaxFactory.Token(SyntaxKind.DoKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedDoWhileStatement() As DoStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DoWhileStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DoWhileStatement(SyntaxFactory.Token(SyntaxKind.DoKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedDoUntilStatement() As DoStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DoUntilStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DoUntilStatement(SyntaxFactory.Token(SyntaxKind.DoKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedSimpleLoopStatement() As LoopStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleLoopStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleLoopStatement(SyntaxFactory.Token(SyntaxKind.LoopKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedLoopWhileStatement() As LoopStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LoopWhileStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LoopWhileStatement(SyntaxFactory.Token(SyntaxKind.LoopKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedLoopUntilStatement() As LoopStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LoopUntilStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LoopUntilStatement(SyntaxFactory.Token(SyntaxKind.LoopKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedWhileClause() As WhileOrUntilClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WhileClause(SyntaxFactory.Token(SyntaxKind.WhileKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WhileClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WhileClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WhileClause(SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedUntilClause() As WhileOrUntilClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.UntilClause(SyntaxFactory.Token(SyntaxKind.UntilKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UntilClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UntilClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.UntilClause(SyntaxFactory.Token(SyntaxKind.UntilKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedWhileStatement() As WhileStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WhileStatement(SyntaxFactory.Token(SyntaxKind.WhileKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WhileStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WhileStatement(SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedForBlock() As ForBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ForBlock(Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ForBlock(GenerateRedForStatement(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedForEachBlock() As ForEachBlockSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ForEachBlock(Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ForEachBlock(GenerateRedForEachStatement(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedForStatement() As ForStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing, SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ForStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedForStepClause() As ForStepClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ForStepClause(SyntaxFactory.Token(SyntaxKind.StepKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForStepClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ForStepClause(SyntaxFactory.Token(SyntaxKind.StepKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedForEachStatement() As ForEachStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ForEachStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.EachKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForEachStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.EachKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.InKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForEachStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EachKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForEachStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ForEachStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.EachKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ForEachStatement(SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.EachKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedNextStatement() As NextStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NextStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NextStatement(SyntaxFactory.Token(SyntaxKind.NextKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedUsingStatement() As UsingStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.UsingStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.UsingStatement(SyntaxFactory.Token(SyntaxKind.UsingKeyword), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedThrowStatement() As ThrowStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ThrowStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ThrowStatement(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), Nothing)
        End Function
 
        Private Shared Function GenerateRedSimpleAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedMidAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MidAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MidAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MidAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MidAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MidAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedAddAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AddAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.PlusEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.PlusEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AddAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.PlusEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSubtractAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SubtractAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.MinusEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubtractAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.MinusEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubtractAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubtractAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SubtractAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.MinusEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedMultiplyAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MultiplyAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.AsteriskEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiplyAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AsteriskEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiplyAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiplyAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MultiplyAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AsteriskEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedDivideAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DivideAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.SlashEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.SlashEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.SlashEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedIntegerDivideAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IntegerDivideAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.BackslashEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IntegerDivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.BackslashEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IntegerDivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IntegerDivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IntegerDivideAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.BackslashEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedExponentiateAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExponentiateAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.CaretEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExponentiateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CaretEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExponentiateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExponentiateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExponentiateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CaretEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedLeftShiftAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LeftShiftAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanLessThanEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LeftShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanLessThanEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LeftShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LeftShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LeftShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanLessThanEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedRightShiftAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RightShiftAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RightShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RightShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RightShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RightShiftAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedConcatenateAssignmentStatement() As AssignmentStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ConcatenateAssignmentStatement(Nothing, SyntaxFactory.Token(SyntaxKind.AmpersandEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConcatenateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AmpersandEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConcatenateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConcatenateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ConcatenateAssignmentStatement(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AmpersandEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedMidExpression() As MidExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MidExpression(GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MidExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedArgumentList())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MidExpression(GenerateRedIdentifierToken(), GenerateRedArgumentList())
        End Function
 
        Private Shared Function GenerateRedCallStatement() As CallStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CallStatement(SyntaxFactory.Token(SyntaxKind.CallKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CallStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedInvocationExpression())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CallStatement(SyntaxFactory.Token(SyntaxKind.CallKeyword), GenerateRedInvocationExpression())
        End Function
 
        Private Shared Function GenerateRedAddHandlerStatement() As AddRemoveHandlerStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AddHandlerStatement(SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddHandlerStatement(SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddHandlerStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddHandlerStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddHandlerStatement(SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AddHandlerStatement(SyntaxFactory.Token(SyntaxKind.AddHandlerKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedRemoveHandlerStatement() As AddRemoveHandlerStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RemoveHandlerStatement(SyntaxFactory.Token(SyntaxKind.RemoveHandlerKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedRaiseEventStatement() As RaiseEventStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RaiseEventStatement(SyntaxFactory.Token(SyntaxKind.RaiseEventKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RaiseEventStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RaiseEventStatement(SyntaxFactory.Token(SyntaxKind.RaiseEventKeyword), GenerateRedIdentifierName(), Nothing)
        End Function
 
        Private Shared Function GenerateRedWithStatement() As WithStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WithStatement(SyntaxFactory.Token(SyntaxKind.WithKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WithStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WithStatement(SyntaxFactory.Token(SyntaxKind.WithKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedReDimStatement() As ReDimStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ReDimStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, New SeparatedSyntaxList(Of RedimClauseSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ReDimStatement(SyntaxFactory.Token(SyntaxKind.ReDimKeyword), Nothing, New SeparatedSyntaxList(Of RedimClauseSyntax)())
        End Function
 
        Private Shared Function GenerateRedReDimPreserveStatement() As ReDimStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ReDimPreserveStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, New SeparatedSyntaxList(Of RedimClauseSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ReDimPreserveStatement(SyntaxFactory.Token(SyntaxKind.ReDimKeyword), Nothing, New SeparatedSyntaxList(Of RedimClauseSyntax)())
        End Function
 
        Private Shared Function GenerateRedRedimClause() As RedimClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RedimClause(Nothing, GenerateRedArgumentList())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RedimClause(GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RedimClause(GenerateRedKeywordEventContainer(), GenerateRedArgumentList())
        End Function
 
        Private Shared Function GenerateRedEraseStatement() As EraseStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EraseStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of ExpressionSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EraseStatement(SyntaxFactory.Token(SyntaxKind.EraseKeyword), New SeparatedSyntaxList(Of ExpressionSyntax)())
        End Function
 
        Private Shared Function GenerateRedCharacterLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CharacterLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CharacterLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedTrueLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TrueLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TrueLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedFalseLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FalseLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FalseLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedNumericLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NumericLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NumericLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedDateLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DateLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DateLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedStringLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.StringLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.StringLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedNothingLiteralExpression() As LiteralExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NothingLiteralExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NothingLiteralExpression(GenerateRedIntegerLiteralToken())
        End Function
 
        Private Shared Function GenerateRedParenthesizedExpression() As ParenthesizedExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTupleExpression() As TupleExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of SimpleArgumentSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), New SeparatedSyntaxList(Of SimpleArgumentSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), New SeparatedSyntaxList(Of SimpleArgumentSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTupleType() As TupleTypeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of TupleElementSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), New SeparatedSyntaxList(Of TupleElementSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), New SeparatedSyntaxList(Of TupleElementSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTypedTupleElement() As TypedTupleElementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypedTupleElement(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypedTupleElement(GenerateRedTupleType())
        End Function
 
        Private Shared Function GenerateRedNamedTupleElement() As NamedTupleElementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NamedTupleElement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NamedTupleElement(GenerateRedIdentifierToken(), Nothing)
        End Function
 
        Private Shared Function GenerateRedMeExpression() As MeExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MeExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MeExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MeExpression(SyntaxFactory.Token(SyntaxKind.MeKeyword))
        End Function
 
        Private Shared Function GenerateRedMyBaseExpression() As MyBaseExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MyBaseExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MyBaseExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MyBaseExpression(SyntaxFactory.Token(SyntaxKind.MyBaseKeyword))
        End Function
 
        Private Shared Function GenerateRedMyClassExpression() As MyClassExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MyClassExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MyClassExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MyClassExpression(SyntaxFactory.Token(SyntaxKind.MyClassKeyword))
        End Function
 
        Private Shared Function GenerateRedGetTypeExpression() As GetTypeExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GetTypeExpression(SyntaxFactory.Token(SyntaxKind.GetTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetTypeExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetTypeExpression(SyntaxFactory.Token(SyntaxKind.GetTypeKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetTypeExpression(SyntaxFactory.Token(SyntaxKind.GetTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GetTypeExpression(SyntaxFactory.Token(SyntaxKind.GetTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTypeOfIsExpression() As TypeOfExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeOfIsExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateRedTupleType())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeOfIsExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateRedTupleType())
        End Function
 
        Private Shared Function GenerateRedTypeOfIsNotExpression() As TypeOfExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeOfIsNotExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.IsNotKeyword), GenerateRedTupleType())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsNotExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsNotKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsNotExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsNotKeyword), GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsNotExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeOfIsNotExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeOfIsNotExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsNotKeyword), GenerateRedTupleType())
        End Function
 
        Private Shared Function GenerateRedGetXmlNamespaceExpression() As GetXmlNamespaceExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GetXmlNamespaceExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetXmlNamespaceExpression(SyntaxFactory.Token(SyntaxKind.GetXmlNamespaceKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GetXmlNamespaceExpression(SyntaxFactory.Token(SyntaxKind.GetXmlNamespaceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GetXmlNamespaceExpression(SyntaxFactory.Token(SyntaxKind.GetXmlNamespaceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedSimpleMemberAccessExpression() As MemberAccessExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleMemberAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.DotToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleMemberAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleMemberAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleMemberAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedDictionaryAccessExpression() As MemberAccessExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DictionaryAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.ExclamationToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DictionaryAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DictionaryAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DictionaryAccessExpression(CType(Nothing, ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.ExclamationToken), GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedXmlElementAccessExpression() As XmlMemberAccessExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlElementAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlElementAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, GenerateRedXmlName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlElementAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, Nothing, GenerateRedXmlName())
        End Function
 
        Private Shared Function GenerateRedXmlDescendantAccessExpression() As XmlMemberAccessExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlDescendantAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDescendantAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, GenerateRedXmlName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlDescendantAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, Nothing, GenerateRedXmlName())
        End Function
 
        Private Shared Function GenerateRedXmlAttributeAccessExpression() As XmlMemberAccessExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlAttributeAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlAttributeAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, GenerateRedXmlName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlAttributeAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), Nothing, Nothing, GenerateRedXmlName())
        End Function
 
        Private Shared Function GenerateRedInvocationExpression() As InvocationExpressionSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.InvocationExpression(Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedObjectCreationExpression() As ObjectCreationExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedPredefinedType(), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, GenerateRedPredefinedType(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedAnonymousObjectCreationExpression() As AnonymousObjectCreationExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedObjectMemberInitializer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, GenerateRedObjectMemberInitializer())
        End Function
 
        Private Shared Function GenerateRedArrayCreationExpression() As ArrayCreationExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, Nothing, Nothing, Nothing, GenerateRedCollectionInitializer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, GenerateRedPredefinedType(), Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, GenerateRedPredefinedType(), Nothing, Nothing, GenerateRedCollectionInitializer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), Nothing, GenerateRedPredefinedType(), Nothing, Nothing, GenerateRedCollectionInitializer())
        End Function
 
        Private Shared Function GenerateRedCollectionInitializer() As CollectionInitializerSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CollectionInitializer(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CollectionInitializer(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CollectionInitializer(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
        End Function
 
        Private Shared Function GenerateRedCTypeExpression() As CTypeExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.CTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.CTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.CTypeKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.CTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.CTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CTypeExpression(SyntaxFactory.Token(SyntaxKind.CTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedDirectCastExpression() As DirectCastExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.DirectCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.DirectCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.DirectCastKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.DirectCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.DirectCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DirectCastExpression(SyntaxFactory.Token(SyntaxKind.DirectCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTryCastExpression() As TryCastExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.TryCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.TryCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.TryCastKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.TryCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.TryCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TryCastExpression(SyntaxFactory.Token(SyntaxKind.TryCastKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedTupleType(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedPredefinedCastExpression() As PredefinedCastExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.PredefinedCastExpression(SyntaxFactory.Token(SyntaxKind.CObjKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PredefinedCastExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PredefinedCastExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PredefinedCastExpression(SyntaxFactory.Token(SyntaxKind.CObjKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PredefinedCastExpression(SyntaxFactory.Token(SyntaxKind.CObjKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.PredefinedCastExpression(SyntaxFactory.Token(SyntaxKind.CObjKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedAddExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AddExpression(Nothing, SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.PlusToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AddExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSubtractExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SubtractExpression(Nothing, SyntaxFactory.Token(SyntaxKind.MinusToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubtractExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.MinusToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubtractExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubtractExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SubtractExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.MinusToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedMultiplyExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MultiplyExpression(Nothing, SyntaxFactory.Token(SyntaxKind.AsteriskToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiplyExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AsteriskToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiplyExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiplyExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MultiplyExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AsteriskToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedDivideExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DivideExpression(Nothing, SyntaxFactory.Token(SyntaxKind.SlashToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.SlashToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.SlashToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedIntegerDivideExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IntegerDivideExpression(Nothing, SyntaxFactory.Token(SyntaxKind.BackslashToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IntegerDivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.BackslashToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IntegerDivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IntegerDivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IntegerDivideExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.BackslashToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedExponentiateExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExponentiateExpression(Nothing, SyntaxFactory.Token(SyntaxKind.CaretToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExponentiateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CaretToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExponentiateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExponentiateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExponentiateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CaretToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedLeftShiftExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LeftShiftExpression(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanLessThanToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LeftShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanLessThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LeftShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LeftShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LeftShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanLessThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedRightShiftExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RightShiftExpression(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RightShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RightShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RightShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RightShiftExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedConcatenateExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ConcatenateExpression(Nothing, SyntaxFactory.Token(SyntaxKind.AmpersandToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConcatenateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AmpersandToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConcatenateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConcatenateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ConcatenateExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AmpersandToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedModuloExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ModuloExpression(Nothing, SyntaxFactory.Token(SyntaxKind.ModKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ModuloExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ModKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ModuloExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ModuloExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ModuloExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ModKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedEqualsExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EqualsExpression(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedNotEqualsExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NotEqualsExpression(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanGreaterThanToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NotEqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanGreaterThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NotEqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NotEqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NotEqualsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanGreaterThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedLessThanExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LessThanExpression(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LessThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LessThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LessThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LessThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedLessThanOrEqualExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LessThanOrEqualExpression(Nothing, SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LessThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LessThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LessThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LessThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedGreaterThanOrEqualExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GreaterThanOrEqualExpression(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GreaterThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GreaterThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GreaterThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GreaterThanOrEqualExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedGreaterThanExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GreaterThanExpression(Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GreaterThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GreaterThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GreaterThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GreaterThanExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedIsExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IsExpression(Nothing, SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IsExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedIsNotExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IsNotExpression(Nothing, SyntaxFactory.Token(SyntaxKind.IsNotKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IsNotExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsNotKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IsNotExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IsNotExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IsNotExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.IsNotKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedLikeExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LikeExpression(Nothing, SyntaxFactory.Token(SyntaxKind.LikeKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LikeExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LikeKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LikeExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.LikeExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LikeExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.LikeKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedOrExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OrExpression(Nothing, SyntaxFactory.Token(SyntaxKind.OrKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.OrKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.OrKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedExclusiveOrExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExclusiveOrExpression(Nothing, SyntaxFactory.Token(SyntaxKind.XorKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExclusiveOrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.XorKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExclusiveOrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExclusiveOrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExclusiveOrExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.XorKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedAndExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AndExpression(Nothing, SyntaxFactory.Token(SyntaxKind.AndKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AndExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AndKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AndExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AndExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AndExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AndKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedOrElseExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OrElseExpression(Nothing, SyntaxFactory.Token(SyntaxKind.OrElseKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrElseExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.OrElseKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrElseExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrElseExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OrElseExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.OrElseKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedAndAlsoExpression() As BinaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AndAlsoExpression(Nothing, SyntaxFactory.Token(SyntaxKind.AndAlsoKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AndAlsoExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AndAlsoKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AndAlsoExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AndAlsoExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AndAlsoExpression(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.AndAlsoKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedUnaryPlusExpression() As UnaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.UnaryPlusExpression(SyntaxFactory.Token(SyntaxKind.PlusToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UnaryPlusExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UnaryPlusExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.UnaryPlusExpression(SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedUnaryMinusExpression() As UnaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.UnaryMinusExpression(SyntaxFactory.Token(SyntaxKind.MinusToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UnaryMinusExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.UnaryMinusExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.UnaryMinusExpression(SyntaxFactory.Token(SyntaxKind.MinusToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedNotExpression() As UnaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NotExpression(SyntaxFactory.Token(SyntaxKind.NotKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NotExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NotExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NotExpression(SyntaxFactory.Token(SyntaxKind.NotKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedAddressOfExpression() As UnaryExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AddressOfExpression(SyntaxFactory.Token(SyntaxKind.AddressOfKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddressOfExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AddressOfExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AddressOfExpression(SyntaxFactory.Token(SyntaxKind.AddressOfKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedBinaryConditionalExpression() As BinaryConditionalExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.BinaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedTernaryConditionalExpression() As TernaryConditionalExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing, SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TernaryConditionalExpression(SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedSingleLineFunctionLambdaExpression() As SingleLineLambdaExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SingleLineFunctionLambdaExpression(Nothing, GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SingleLineFunctionLambdaExpression(GenerateRedSubLambdaHeader(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SingleLineFunctionLambdaExpression(GenerateRedSubLambdaHeader(), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSingleLineSubLambdaExpression() As SingleLineLambdaExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SingleLineSubLambdaExpression(Nothing, GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SingleLineSubLambdaExpression(GenerateRedSubLambdaHeader(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SingleLineSubLambdaExpression(GenerateRedSubLambdaHeader(), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedMultiLineFunctionLambdaExpression() As MultiLineLambdaExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MultiLineFunctionLambdaExpression(Nothing, Nothing, GenerateRedEndSubStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiLineFunctionLambdaExpression(GenerateRedSubLambdaHeader(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MultiLineFunctionLambdaExpression(GenerateRedSubLambdaHeader(), Nothing, GenerateRedEndSubStatement())
        End Function
 
        Private Shared Function GenerateRedMultiLineSubLambdaExpression() As MultiLineLambdaExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.MultiLineSubLambdaExpression(Nothing, Nothing, GenerateRedEndSubStatement())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.MultiLineSubLambdaExpression(GenerateRedSubLambdaHeader(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.MultiLineSubLambdaExpression(GenerateRedSubLambdaHeader(), Nothing, GenerateRedEndSubStatement())
        End Function
 
        Private Shared Function GenerateRedSubLambdaHeader() As LambdaHeaderSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SubLambdaHeader(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SubLambdaHeader(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SubLambdaHeader(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedFunctionLambdaHeader() As LambdaHeaderSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FunctionLambdaHeader(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.FunctionLambdaHeader(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FunctionLambdaHeader(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.FunctionKeyword), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedArgumentList() As ArgumentListSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedOmittedArgument() As OmittedArgumentSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OmittedArgument(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OmittedArgument(SyntaxFactory.Token(SyntaxKind.EmptyToken))
        End Function
 
        Private Shared Function GenerateRedSimpleArgument() As SimpleArgumentSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleArgument(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleArgument(Nothing, GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedNameColonEquals() As NameColonEqualsSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NameColonEquals(Nothing, SyntaxFactory.Token(SyntaxKind.ColonEqualsToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NameColonEquals(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NameColonEquals(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonEqualsToken))
        End Function
 
        Private Shared Function GenerateRedRangeArgument() As RangeArgumentSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RangeArgument(Nothing, SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RangeArgument(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RangeArgument(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RangeArgument(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ToKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedQueryExpression() As QueryExpressionSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.QueryExpression(SyntaxFactory.SingletonList(Of QueryClauseSyntax)(GenerateRedFromClause()))
        End Function
 
        Private Shared Function GenerateRedCollectionRangeVariable() As CollectionRangeVariableSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CollectionRangeVariable(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CollectionRangeVariable(GenerateRedModifiedIdentifier(), Nothing, SyntaxFactory.Token(SyntaxKind.InKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CollectionRangeVariable(GenerateRedModifiedIdentifier(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CollectionRangeVariable(GenerateRedModifiedIdentifier(), Nothing, SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedExpressionRangeVariable() As ExpressionRangeVariableSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExpressionRangeVariable(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExpressionRangeVariable(Nothing, GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedAggregationRangeVariable() As AggregationRangeVariableSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AggregationRangeVariable(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AggregationRangeVariable(Nothing, GenerateRedFunctionAggregation())
        End Function
 
        Private Shared Function GenerateRedVariableNameEquals() As VariableNameEqualsSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.VariableNameEquals(Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.VariableNameEquals(GenerateRedModifiedIdentifier(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.VariableNameEquals(GenerateRedModifiedIdentifier(), Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken))
        End Function
 
        Private Shared Function GenerateRedFunctionAggregation() As FunctionAggregationSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FunctionAggregation(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, Nothing, Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FunctionAggregation(GenerateRedIdentifierToken(), Nothing, Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedGroupAggregation() As GroupAggregationSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GroupAggregation(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GroupAggregation(SyntaxFactory.Token(SyntaxKind.GroupKeyword))
        End Function
 
        Private Shared Function GenerateRedFromClause() As FromClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)())
        End Function
 
        Private Shared Function GenerateRedLetClause() As LetClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)())
        End Function
 
        Private Shared Function GenerateRedAggregateClause() As AggregateClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AggregateClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AggregateClause(SyntaxFactory.Token(SyntaxKind.AggregateKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AggregateClause(SyntaxFactory.Token(SyntaxKind.AggregateKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
        End Function
 
        Private Shared Function GenerateRedDistinctClause() As DistinctClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DistinctClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DistinctClause(SyntaxFactory.Token(SyntaxKind.DistinctKeyword))
        End Function
 
        Private Shared Function GenerateRedWhereClause() As WhereClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSkipWhileClause() As PartitionWhileClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SkipWhileClause(SyntaxFactory.Token(SyntaxKind.SkipKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SkipWhileClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SkipWhileClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SkipWhileClause(SyntaxFactory.Token(SyntaxKind.SkipKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SkipWhileClause(SyntaxFactory.Token(SyntaxKind.SkipKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedTakeWhileClause() As PartitionWhileClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TakeWhileClause(SyntaxFactory.Token(SyntaxKind.TakeKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TakeWhileClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TakeWhileClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TakeWhileClause(SyntaxFactory.Token(SyntaxKind.TakeKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TakeWhileClause(SyntaxFactory.Token(SyntaxKind.TakeKeyword), SyntaxFactory.Token(SyntaxKind.WhileKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSkipClause() As PartitionClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SkipClause(SyntaxFactory.Token(SyntaxKind.SkipKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SkipClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SkipClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SkipClause(SyntaxFactory.Token(SyntaxKind.SkipKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedTakeClause() As PartitionClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TakeClause(SyntaxFactory.Token(SyntaxKind.TakeKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TakeClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TakeClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TakeClause(SyntaxFactory.Token(SyntaxKind.TakeKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedGroupByClause() As GroupByClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GroupByClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ByKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GroupByClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GroupByClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ByKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GroupByClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.ByKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
        End Function
 
        Private Shared Function GenerateRedJoinCondition() As JoinConditionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.JoinCondition(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.JoinCondition(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.JoinCondition(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.JoinCondition(GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.EqualsKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedSimpleJoinClause() As SimpleJoinClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SimpleJoinClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.OnKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.SimpleJoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SimpleJoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.OnKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)())
        End Function
 
        Private Shared Function GenerateRedGroupJoinClause() As GroupJoinClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GroupJoinClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.JoinKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.OnKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GroupJoinClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.OnKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GroupJoinClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), SyntaxFactory.Token(SyntaxKind.JoinKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GroupJoinClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), SyntaxFactory.Token(SyntaxKind.JoinKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.OnKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GroupJoinClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), SyntaxFactory.Token(SyntaxKind.JoinKeyword), New SeparatedSyntaxList(Of CollectionRangeVariableSyntax)(), Nothing, SyntaxFactory.Token(SyntaxKind.OnKeyword), New SeparatedSyntaxList(Of JoinConditionSyntax)(), SyntaxFactory.Token(SyntaxKind.IntoKeyword), New SeparatedSyntaxList(Of AggregationRangeVariableSyntax)())
        End Function
 
        Private Shared Function GenerateRedOrderByClause() As OrderByClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ByKeyword), New SeparatedSyntaxList(Of OrderingSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of OrderingSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderKeyword), SyntaxFactory.Token(SyntaxKind.ByKeyword), New SeparatedSyntaxList(Of OrderingSyntax)())
        End Function
 
        Private Shared Function GenerateRedAscendingOrdering() As OrderingSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AscendingOrdering(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AscendingOrdering(GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedDescendingOrdering() As OrderingSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DescendingOrdering(Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DescendingOrdering(GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedSelectClause() As SelectClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.SelectKeyword), New SeparatedSyntaxList(Of ExpressionRangeVariableSyntax)())
        End Function
 
        Private Shared Function GenerateRedXmlDocument() As XmlDocumentSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlDocument(Nothing, Nothing, GenerateRedXmlElement(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDocument(GenerateRedXmlDeclaration(), Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlDocument(GenerateRedXmlDeclaration(), Nothing, GenerateRedXmlElement(), Nothing)
        End Function
 
        Private Shared Function GenerateRedXmlDeclaration() As XmlDeclarationSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlDeclaration(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), SyntaxFactory.Token(SyntaxKind.XmlKeyword), Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDeclaration(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.XmlKeyword), GenerateRedXmlDeclarationOption(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDeclaration(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlDeclarationOption(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDeclaration(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), SyntaxFactory.Token(SyntaxKind.XmlKeyword), GenerateRedXmlDeclarationOption(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlDeclaration(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), SyntaxFactory.Token(SyntaxKind.XmlKeyword), GenerateRedXmlDeclarationOption(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlDeclarationOption() As XmlDeclarationOptionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlDeclarationOption(GenerateRedXmlNameToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDeclarationOption(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedXmlString())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlDeclarationOption(GenerateRedXmlNameToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlString())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlDeclarationOption(GenerateRedXmlNameToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedXmlString())
        End Function
 
        Private Shared Function GenerateRedXmlElement() As XmlElementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlElement(Nothing, Nothing, GenerateRedXmlElementEndTag())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlElement(GenerateRedXmlElementStartTag(), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlElement(GenerateRedXmlElementStartTag(), Nothing, GenerateRedXmlElementEndTag())
        End Function
 
        Private Shared Function GenerateRedXmlText() As XmlTextSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.XmlText(SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()))
        End Function
 
        Private Shared Function GenerateRedXmlElementStartTag() As XmlElementStartTagSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlName(), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlName(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlName(), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlElementEndTag() As XmlElementEndTagSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlEmptyElement() As XmlEmptyElementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlName(), Nothing, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlName(), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlName(), Nothing, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlAttribute() As XmlAttributeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlAttribute(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedXmlString())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlString())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedXmlString())
        End Function
 
        Private Shared Function GenerateRedXmlString() As XmlStringSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlString(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlString(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlString(SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlString(SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlString(SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), Nothing, SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
        End Function
 
        Private Shared Function GenerateRedXmlPrefixName() As XmlPrefixNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlPrefixName(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlPrefixName(GenerateRedXmlNameToken())
        End Function
 
        Private Shared Function GenerateRedXmlName() As XmlNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlName(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlName(Nothing, GenerateRedXmlNameToken())
        End Function
 
        Private Shared Function GenerateRedXmlBracketedName() As XmlBracketedNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlBracketedName(SyntaxFactory.Token(SyntaxKind.LessThanToken), Nothing, SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlBracketedName(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlBracketedName(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlBracketedName(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlPrefix() As XmlPrefixSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlPrefix(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlPrefix(GenerateRedXmlNameToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlPrefix(GenerateRedXmlNameToken(), SyntaxFactory.Token(SyntaxKind.ColonToken))
        End Function
 
        Private Shared Function GenerateRedXmlComment() As XmlCommentSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.MinusMinusGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.LessThanExclamationMinusMinusToken), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.LessThanExclamationMinusMinusToken), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.MinusMinusGreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlProcessingInstruction() As XmlProcessingInstructionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedXmlNameToken(), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), GenerateRedXmlNameToken(), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.LessThanQuestionToken), GenerateRedXmlNameToken(), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.QuestionGreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedXmlCDataSection() As XmlCDataSectionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.EndCDataToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.BeginCDataToken), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.BeginCDataToken), SyntaxTokenList.Create(GenerateRedXmlTextLiteralToken()), SyntaxFactory.Token(SyntaxKind.EndCDataToken))
        End Function
 
        Private Shared Function GenerateRedXmlEmbeddedExpression() As XmlEmbeddedExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlEmbeddedExpression(SyntaxFactory.Token(SyntaxKind.LessThanPercentEqualsToken), Nothing, SyntaxFactory.Token(SyntaxKind.PercentGreaterThanToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlEmbeddedExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.PercentGreaterThanToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlEmbeddedExpression(SyntaxFactory.Token(SyntaxKind.LessThanPercentEqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlEmbeddedExpression(SyntaxFactory.Token(SyntaxKind.LessThanPercentEqualsToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.PercentGreaterThanToken))
        End Function
 
        Private Shared Function GenerateRedArrayType() As ArrayTypeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ArrayType(Nothing, SyntaxFactory.SingletonList(Of ArrayRankSpecifierSyntax)(GenerateRedArrayRankSpecifier()))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ArrayType(GenerateRedPredefinedType(), SyntaxFactory.SingletonList(Of ArrayRankSpecifierSyntax)(GenerateRedArrayRankSpecifier()))
        End Function
 
        Private Shared Function GenerateRedNullableType() As NullableTypeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NullableType(Nothing, SyntaxFactory.Token(SyntaxKind.QuestionToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NullableType(GenerateRedPredefinedType(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NullableType(GenerateRedPredefinedType(), SyntaxFactory.Token(SyntaxKind.QuestionToken))
        End Function
 
        Private Shared Function GenerateRedPredefinedType() As PredefinedTypeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword))
        End Function
 
        Private Shared Function GenerateRedIdentifierName() As IdentifierNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IdentifierName(GenerateRedIdentifierToken())
        End Function
 
        Private Shared Function GenerateRedGenericName() As GenericNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GenericName(GenerateRedIdentifierToken(), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.GenericName(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedTypeArgumentList())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GenericName(GenerateRedIdentifierToken(), GenerateRedTypeArgumentList())
        End Function
 
        Private Shared Function GenerateRedQualifiedName() As QualifiedNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.QualifiedName(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.QualifiedName(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.QualifiedName(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.QualifiedName(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedIdentifierName())
        End Function
 
        Private Shared Function GenerateRedGlobalName() As GlobalNameSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.GlobalName(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.GlobalName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword))
        End Function
 
        Private Shared Function GenerateRedTypeArgumentList() As TypeArgumentListSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OfKeyword), New SeparatedSyntaxList(Of TypeSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of TypeSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.OfKeyword), New SeparatedSyntaxList(Of TypeSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.OfKeyword), New SeparatedSyntaxList(Of TypeSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedCrefReference() As CrefReferenceSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CrefReference(Nothing, Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CrefReference(GenerateRedTupleType(), Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedCrefSignature() As CrefSignatureSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CrefSignature(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of CrefSignaturePartSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CrefSignature(SyntaxFactory.Token(SyntaxKind.OpenParenToken), New SeparatedSyntaxList(Of CrefSignaturePartSyntax)(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CrefSignature(SyntaxFactory.Token(SyntaxKind.OpenParenToken), New SeparatedSyntaxList(Of CrefSignaturePartSyntax)(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedCrefSignaturePart() As CrefSignaturePartSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.CrefSignaturePart(Nothing, Nothing)
        End Function
 
        Private Shared Function GenerateRedCrefOperatorReference() As CrefOperatorReferenceSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CrefOperatorReference(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.CTypeKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CrefOperatorReference(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.CrefOperatorReference(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CrefOperatorReference(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.CTypeKeyword))
        End Function
 
        Private Shared Function GenerateRedQualifiedCrefOperatorReference() As QualifiedCrefOperatorReferenceSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.QualifiedCrefOperatorReference(Nothing, SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedCrefOperatorReference())
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.QualifiedCrefOperatorReference(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.QualifiedCrefOperatorReference(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedCrefOperatorReference())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.QualifiedCrefOperatorReference(GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateRedCrefOperatorReference())
        End Function
 
        Private Shared Function GenerateRedYieldStatement() As YieldStatementSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.YieldStatement(SyntaxFactory.Token(SyntaxKind.YieldKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.YieldStatement(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.YieldStatement(SyntaxFactory.Token(SyntaxKind.YieldKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedAwaitExpression() As AwaitExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedXmlNameToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.XmlNameToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, SyntaxKind.IdentifierName, SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedXmlTextLiteralToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.XmlTextLiteralToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, "Bar", SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedXmlEntityLiteralToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.XmlEntityLiteralToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, "Bar", SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedDocumentationCommentLineBreakToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.DocumentationCommentLineBreakToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, "Bar", SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedInterpolatedStringTextToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.InterpolatedStringTextToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, "Bar", SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedDecimalLiteralToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.DecimalLiteralToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, TypeCharacter.DecimalLiteral, 42, SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedDateLiteralToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.DateLiteralToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, New DateTime(2008,11,04), SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedStringLiteralToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.StringLiteralToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, "Bar", SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedCharacterLiteralToken() As SyntaxToken
            Dim exceptionTest as boolean = false
            return SyntaxFactory.CharacterLiteralToken(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")), String.Empty, "E"C, SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
        End Function
 
        Private Shared Function GenerateRedSkippedTokensTrivia() As SkippedTokensTriviaSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.SkippedTokensTrivia(Nothing)
        End Function
 
        Private Shared Function GenerateRedDocumentationCommentTrivia() As DocumentationCommentTriviaSyntax
            Dim exceptionTest as boolean = false
            return SyntaxFactory.DocumentationCommentTrivia(Nothing)
        End Function
 
        Private Shared Function GenerateRedXmlCrefAttribute() As XmlCrefAttributeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlCrefAttribute(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), Nothing, SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlCrefAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedCrefReference(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
        End Function
 
        Private Shared Function GenerateRedXmlNameAttribute() As XmlNameAttributeSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.XmlNameAttribute(Nothing, SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), Nothing, SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.XmlNameAttribute(GenerateRedXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken), GenerateRedIdentifierName(), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
        End Function
 
        Private Shared Function GenerateRedConditionalAccessExpression() As ConditionalAccessExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ConditionalAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.QuestionToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConditionalAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedDictionaryAccessExpression())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ConditionalAccessExpression(Nothing, SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateRedDictionaryAccessExpression())
        End Function
 
        Private Shared Function GenerateRedNameOfExpression() As NameOfExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.NameOfExpression(SyntaxFactory.Token(SyntaxKind.NameOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), Nothing, SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NameOfExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NameOfExpression(SyntaxFactory.Token(SyntaxKind.NameOfKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.NameOfExpression(SyntaxFactory.Token(SyntaxKind.NameOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.NameOfExpression(SyntaxFactory.Token(SyntaxKind.NameOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedKeywordEventContainer(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedInterpolatedStringExpression() As InterpolatedStringExpressionSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.SingletonList(Of InterpolatedStringContentSyntax)(GenerateRedInterpolatedStringText()), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.DollarSignDoubleQuoteToken), SyntaxFactory.SingletonList(Of InterpolatedStringContentSyntax)(GenerateRedInterpolatedStringText()), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.DollarSignDoubleQuoteToken), SyntaxFactory.SingletonList(Of InterpolatedStringContentSyntax)(GenerateRedInterpolatedStringText()), SyntaxFactory.Token(SyntaxKind.DoubleQuoteToken))
        End Function
 
        Private Shared Function GenerateRedInterpolatedStringText() As InterpolatedStringTextSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InterpolatedStringText(GenerateRedInterpolatedStringTextToken())
        End Function
 
        Private Shared Function GenerateRedInterpolation() As InterpolationSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), Nothing, Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), GenerateRedKeywordEventContainer(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), GenerateRedKeywordEventContainer(), Nothing, Nothing, SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
        End Function
 
        Private Shared Function GenerateRedInterpolationAlignmentClause() As InterpolationAlignmentClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Token(SyntaxKind.CommaToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedInterpolationFormatClause() As InterpolationFormatClauseSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.InterpolationFormatClause(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedInterpolatedStringTextToken())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.InterpolationFormatClause(SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.InterpolationFormatClause(SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateRedInterpolatedStringTextToken())
        End Function
 
        Private Shared Function GenerateRedWhitespaceTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.WhitespaceTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.WhitespaceTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedEndOfLineTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndOfLineTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndOfLineTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedColonTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ColonTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ColonTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedCommentTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.CommentTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.CommentTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedConflictMarkerTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ConflictMarkerTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ConflictMarkerTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedLineContinuationTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.LineContinuationTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.LineContinuationTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedDocumentationCommentExteriorTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DocumentationCommentExteriorTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DocumentationCommentExteriorTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedDisabledTextTrivia() As SyntaxTrivia
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DisabledTextTrivia(Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DisabledTextTrivia(String.Empty)
        End Function
 
        Private Shared Function GenerateRedConstDirectiveTrivia() As ConstDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ConstDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ConstKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken), Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConstDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ConstKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConstDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConstDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ConstKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ConstDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ConstKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ConstDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ConstKeyword), GenerateRedIdentifierToken(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateRedKeywordEventContainer())
        End Function
 
        Private Shared Function GenerateRedIfDirectiveTrivia() As IfDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.IfKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedElseIfDirectiveTrivia() As IfDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.IfKeyword), Nothing, Nothing)
            catch e as ArgumentNullException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ElseIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), Nothing, SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ElseIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ElseIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedKeywordEventContainer(), Nothing)
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), Nothing, SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateRedKeywordEventContainer(), Nothing)
        End Function
 
        Private Shared Function GenerateRedElseDirectiveTrivia() As ElseDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ElseKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElseKeyword))
        End Function
 
        Private Shared Function GenerateRedEndIfDirectiveTrivia() As EndIfDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.IfKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.IfKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.IfKeyword))
        End Function
 
        Private Shared Function GenerateRedRegionDirectiveTrivia() As RegionDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.RegionKeyword), GenerateRedStringLiteralToken())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedStringLiteralToken())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), GenerateRedStringLiteralToken())
        End Function
 
        Private Shared Function GenerateRedEndRegionDirectiveTrivia() As EndRegionDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.RegionKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.RegionKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndKeyword), SyntaxFactory.Token(SyntaxKind.RegionKeyword))
        End Function
 
        Private Shared Function GenerateRedExternalChecksumDirectiveTrivia() As ExternalChecksumDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ExternalChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalChecksumKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateRedStringLiteralToken(), SyntaxFactory.Token(SyntaxKind.CloseParenToken))
        End Function
 
        Private Shared Function GenerateRedEnableWarningDirectiveTrivia() As EnableWarningDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.EnableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.EnableKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EnableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.EnableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EnableKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.EnableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EnableKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
        End Function
 
        Private Shared Function GenerateRedDisableWarningDirectiveTrivia() As DisableWarningDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.DisableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.DisableKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DisableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.DisableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DisableKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.DisableWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DisableKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), New SeparatedSyntaxList(Of IdentifierNameSyntax)())
        End Function
 
        Private Shared Function GenerateRedReferenceDirectiveTrivia() As ReferenceDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), GenerateRedStringLiteralToken())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword), GenerateRedStringLiteralToken())
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            Try
            SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), GenerateRedStringLiteralToken())
        End Function
 
        Private Shared Function GenerateRedBadDirectiveTrivia() As BadDirectiveTriviaSyntax
            Dim exceptionTest as boolean = false
            Try
            SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.ExternalSourceKeyword))
            catch e as ArgumentException
            exceptionTest = true
            End Try
            Debug.Assert(exceptionTest)
            exceptionTest = false
 
            return SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken))
        End Function
 
#end region
 
#region "Red Factory Tests"
        <Fact>
        Public Sub TestRedEmptyStatement()
            dim objectUnderTest = GenerateRedEmptyStatement()
            Assert.NotNull(objectUnderTest.empty)
            Dim withObj = objectUnderTest.WithEmpty(objectUnderTest.Empty)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndIfStatement()
            dim objectUnderTest = GenerateRedEndIfStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndUsingStatement()
            dim objectUnderTest = GenerateRedEndUsingStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndWithStatement()
            dim objectUnderTest = GenerateRedEndWithStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSelectStatement()
            dim objectUnderTest = GenerateRedEndSelectStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndStructureStatement()
            dim objectUnderTest = GenerateRedEndStructureStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndEnumStatement()
            dim objectUnderTest = GenerateRedEndEnumStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndInterfaceStatement()
            dim objectUnderTest = GenerateRedEndInterfaceStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndClassStatement()
            dim objectUnderTest = GenerateRedEndClassStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndModuleStatement()
            dim objectUnderTest = GenerateRedEndModuleStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndNamespaceStatement()
            dim objectUnderTest = GenerateRedEndNamespaceStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSubStatement()
            dim objectUnderTest = GenerateRedEndSubStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndFunctionStatement()
            dim objectUnderTest = GenerateRedEndFunctionStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndGetStatement()
            dim objectUnderTest = GenerateRedEndGetStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSetStatement()
            dim objectUnderTest = GenerateRedEndSetStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndPropertyStatement()
            dim objectUnderTest = GenerateRedEndPropertyStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndOperatorStatement()
            dim objectUnderTest = GenerateRedEndOperatorStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndEventStatement()
            dim objectUnderTest = GenerateRedEndEventStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndAddHandlerStatement()
            dim objectUnderTest = GenerateRedEndAddHandlerStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndRemoveHandlerStatement()
            dim objectUnderTest = GenerateRedEndRemoveHandlerStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndRaiseEventStatement()
            dim objectUnderTest = GenerateRedEndRaiseEventStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndWhileStatement()
            dim objectUnderTest = GenerateRedEndWhileStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndTryStatement()
            dim objectUnderTest = GenerateRedEndTryStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSyncLockStatement()
            dim objectUnderTest = GenerateRedEndSyncLockStatement()
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithEndKeyword(objectUnderTest.EndKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCompilationUnit()
            dim objectUnderTest = GenerateRedCompilationUnit()
            Assert.NotNull(objectUnderTest.endOfFileToken)
            Dim withObj = objectUnderTest.WithOptions(objectUnderTest.Options).WithImports(objectUnderTest.Imports).WithAttributes(objectUnderTest.Attributes).WithMembers(objectUnderTest.Members).WithEndOfFileToken(objectUnderTest.EndOfFileToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOptionStatement()
            dim objectUnderTest = GenerateRedOptionStatement()
            Assert.NotNull(objectUnderTest.optionKeyword)
            Assert.NotNull(objectUnderTest.nameKeyword)
            Dim withObj = objectUnderTest.WithOptionKeyword(objectUnderTest.OptionKeyword).WithNameKeyword(objectUnderTest.NameKeyword).WithValueKeyword(objectUnderTest.ValueKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedImportsStatement()
            dim objectUnderTest = GenerateRedImportsStatement()
            Assert.NotNull(objectUnderTest.importsKeyword)
            Dim withObj = objectUnderTest.WithImportsKeyword(objectUnderTest.ImportsKeyword).WithImportsClauses(objectUnderTest.ImportsClauses)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleImportsClause()
            dim objectUnderTest = GenerateRedSimpleImportsClause()
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithAlias(objectUnderTest.Alias).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedImportAliasClause()
            dim objectUnderTest = GenerateRedImportAliasClause()
            Assert.NotNull(objectUnderTest.identifier)
            Assert.NotNull(objectUnderTest.equalsToken)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier).WithEqualsToken(objectUnderTest.EqualsToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlNamespaceImportsClause()
            dim objectUnderTest = GenerateRedXmlNamespaceImportsClause()
            Assert.NotNull(objectUnderTest.lessThanToken)
            Assert.NotNull(objectUnderTest.xmlNamespace)
            Assert.NotNull(objectUnderTest.greaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanToken(objectUnderTest.LessThanToken).WithXmlNamespace(objectUnderTest.XmlNamespace).WithGreaterThanToken(objectUnderTest.GreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNamespaceBlock()
            dim objectUnderTest = GenerateRedNamespaceBlock()
            Assert.NotNull(objectUnderTest.namespaceStatement)
            Assert.NotNull(objectUnderTest.endNamespaceStatement)
            Dim withObj = objectUnderTest.WithNamespaceStatement(objectUnderTest.NamespaceStatement).WithMembers(objectUnderTest.Members).WithEndNamespaceStatement(objectUnderTest.EndNamespaceStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNamespaceStatement()
            dim objectUnderTest = GenerateRedNamespaceStatement()
            Assert.NotNull(objectUnderTest.namespaceKeyword)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithNamespaceKeyword(objectUnderTest.NamespaceKeyword).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedModuleBlock()
            dim objectUnderTest = GenerateRedModuleBlock()
            Assert.NotNull(objectUnderTest.moduleStatement)
            Assert.NotNull(objectUnderTest.endModuleStatement)
            Dim withObj = objectUnderTest.WithModuleStatement(objectUnderTest.ModuleStatement).WithInherits(objectUnderTest.Inherits).WithImplements(objectUnderTest.Implements).WithMembers(objectUnderTest.Members).WithEndModuleStatement(objectUnderTest.EndModuleStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedStructureBlock()
            dim objectUnderTest = GenerateRedStructureBlock()
            Assert.NotNull(objectUnderTest.structureStatement)
            Assert.NotNull(objectUnderTest.endStructureStatement)
            Dim withObj = objectUnderTest.WithStructureStatement(objectUnderTest.StructureStatement).WithInherits(objectUnderTest.Inherits).WithImplements(objectUnderTest.Implements).WithMembers(objectUnderTest.Members).WithEndStructureStatement(objectUnderTest.EndStructureStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterfaceBlock()
            dim objectUnderTest = GenerateRedInterfaceBlock()
            Assert.NotNull(objectUnderTest.interfaceStatement)
            Assert.NotNull(objectUnderTest.endInterfaceStatement)
            Dim withObj = objectUnderTest.WithInterfaceStatement(objectUnderTest.InterfaceStatement).WithInherits(objectUnderTest.Inherits).WithImplements(objectUnderTest.Implements).WithMembers(objectUnderTest.Members).WithEndInterfaceStatement(objectUnderTest.EndInterfaceStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedClassBlock()
            dim objectUnderTest = GenerateRedClassBlock()
            Assert.NotNull(objectUnderTest.classStatement)
            Assert.NotNull(objectUnderTest.endClassStatement)
            Dim withObj = objectUnderTest.WithClassStatement(objectUnderTest.ClassStatement).WithInherits(objectUnderTest.Inherits).WithImplements(objectUnderTest.Implements).WithMembers(objectUnderTest.Members).WithEndClassStatement(objectUnderTest.EndClassStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEnumBlock()
            dim objectUnderTest = GenerateRedEnumBlock()
            Assert.NotNull(objectUnderTest.enumStatement)
            Assert.NotNull(objectUnderTest.endEnumStatement)
            Dim withObj = objectUnderTest.WithEnumStatement(objectUnderTest.EnumStatement).WithMembers(objectUnderTest.Members).WithEndEnumStatement(objectUnderTest.EndEnumStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInheritsStatement()
            dim objectUnderTest = GenerateRedInheritsStatement()
            Assert.NotNull(objectUnderTest.inheritsKeyword)
            Assert.NotNull(objectUnderTest.types)
            Dim withObj = objectUnderTest.WithInheritsKeyword(objectUnderTest.InheritsKeyword).WithTypes(objectUnderTest.Types)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedImplementsStatement()
            dim objectUnderTest = GenerateRedImplementsStatement()
            Assert.NotNull(objectUnderTest.implementsKeyword)
            Assert.NotNull(objectUnderTest.types)
            Dim withObj = objectUnderTest.WithImplementsKeyword(objectUnderTest.ImplementsKeyword).WithTypes(objectUnderTest.Types)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedModuleStatement()
            dim objectUnderTest = GenerateRedModuleStatement()
            Assert.NotNull(objectUnderTest.moduleKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithModuleKeyword(objectUnderTest.ModuleKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedStructureStatement()
            dim objectUnderTest = GenerateRedStructureStatement()
            Assert.NotNull(objectUnderTest.structureKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithStructureKeyword(objectUnderTest.StructureKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterfaceStatement()
            dim objectUnderTest = GenerateRedInterfaceStatement()
            Assert.NotNull(objectUnderTest.interfaceKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithInterfaceKeyword(objectUnderTest.InterfaceKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedClassStatement()
            dim objectUnderTest = GenerateRedClassStatement()
            Assert.NotNull(objectUnderTest.classKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithClassKeyword(objectUnderTest.ClassKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEnumStatement()
            dim objectUnderTest = GenerateRedEnumStatement()
            Assert.NotNull(objectUnderTest.enumKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithEnumKeyword(objectUnderTest.EnumKeyword).WithIdentifier(objectUnderTest.Identifier).WithUnderlyingType(objectUnderTest.UnderlyingType)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterList()
            dim objectUnderTest = GenerateRedTypeParameterList()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.ofKeyword)
            Assert.NotNull(objectUnderTest.parameters)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithOfKeyword(objectUnderTest.OfKeyword).WithParameters(objectUnderTest.Parameters).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameter()
            dim objectUnderTest = GenerateRedTypeParameter()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithVarianceKeyword(objectUnderTest.VarianceKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterConstraintClause(objectUnderTest.TypeParameterConstraintClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterSingleConstraintClause()
            dim objectUnderTest = GenerateRedTypeParameterSingleConstraintClause()
            Assert.NotNull(objectUnderTest.asKeyword)
            Assert.NotNull(objectUnderTest.constraint)
            Dim withObj = objectUnderTest.WithAsKeyword(objectUnderTest.AsKeyword).WithConstraint(objectUnderTest.Constraint)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterMultipleConstraintClause()
            dim objectUnderTest = GenerateRedTypeParameterMultipleConstraintClause()
            Assert.NotNull(objectUnderTest.asKeyword)
            Assert.NotNull(objectUnderTest.openBraceToken)
            Assert.NotNull(objectUnderTest.constraints)
            Assert.NotNull(objectUnderTest.closeBraceToken)
            Dim withObj = objectUnderTest.WithAsKeyword(objectUnderTest.AsKeyword).WithOpenBraceToken(objectUnderTest.OpenBraceToken).WithConstraints(objectUnderTest.Constraints).WithCloseBraceToken(objectUnderTest.CloseBraceToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNewConstraint()
            dim objectUnderTest = GenerateRedNewConstraint()
            Assert.NotNull(objectUnderTest.constraintKeyword)
            Dim withObj = objectUnderTest.WithConstraintKeyword(objectUnderTest.ConstraintKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedClassConstraint()
            dim objectUnderTest = GenerateRedClassConstraint()
            Assert.NotNull(objectUnderTest.constraintKeyword)
            Dim withObj = objectUnderTest.WithConstraintKeyword(objectUnderTest.ConstraintKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedStructureConstraint()
            dim objectUnderTest = GenerateRedStructureConstraint()
            Assert.NotNull(objectUnderTest.constraintKeyword)
            Dim withObj = objectUnderTest.WithConstraintKeyword(objectUnderTest.ConstraintKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeConstraint()
            dim objectUnderTest = GenerateRedTypeConstraint()
            Assert.NotNull(objectUnderTest.type)
            Dim withObj = objectUnderTest.WithType(objectUnderTest.Type)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEnumMemberDeclaration()
            dim objectUnderTest = GenerateRedEnumMemberDeclaration()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithIdentifier(objectUnderTest.Identifier).WithInitializer(objectUnderTest.Initializer)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSubBlock()
            dim objectUnderTest = GenerateRedSubBlock()
            Assert.NotNull(objectUnderTest.subOrFunctionStatement)
            Assert.NotNull(objectUnderTest.endSubOrFunctionStatement)
            Dim withObj = objectUnderTest.WithSubOrFunctionStatement(objectUnderTest.SubOrFunctionStatement).WithStatements(objectUnderTest.Statements).WithEndSubOrFunctionStatement(objectUnderTest.EndSubOrFunctionStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionBlock()
            dim objectUnderTest = GenerateRedFunctionBlock()
            Assert.NotNull(objectUnderTest.subOrFunctionStatement)
            Assert.NotNull(objectUnderTest.endSubOrFunctionStatement)
            Dim withObj = objectUnderTest.WithSubOrFunctionStatement(objectUnderTest.SubOrFunctionStatement).WithStatements(objectUnderTest.Statements).WithEndSubOrFunctionStatement(objectUnderTest.EndSubOrFunctionStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedConstructorBlock()
            dim objectUnderTest = GenerateRedConstructorBlock()
            Assert.NotNull(objectUnderTest.subNewStatement)
            Assert.NotNull(objectUnderTest.endSubStatement)
            Dim withObj = objectUnderTest.WithSubNewStatement(objectUnderTest.SubNewStatement).WithStatements(objectUnderTest.Statements).WithEndSubStatement(objectUnderTest.EndSubStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOperatorBlock()
            dim objectUnderTest = GenerateRedOperatorBlock()
            Assert.NotNull(objectUnderTest.operatorStatement)
            Assert.NotNull(objectUnderTest.endOperatorStatement)
            Dim withObj = objectUnderTest.WithOperatorStatement(objectUnderTest.OperatorStatement).WithStatements(objectUnderTest.Statements).WithEndOperatorStatement(objectUnderTest.EndOperatorStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGetAccessorBlock()
            dim objectUnderTest = GenerateRedGetAccessorBlock()
            Assert.NotNull(objectUnderTest.accessorStatement)
            Assert.NotNull(objectUnderTest.endAccessorStatement)
            Dim withObj = objectUnderTest.WithAccessorStatement(objectUnderTest.AccessorStatement).WithStatements(objectUnderTest.Statements).WithEndAccessorStatement(objectUnderTest.EndAccessorStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSetAccessorBlock()
            dim objectUnderTest = GenerateRedSetAccessorBlock()
            Assert.NotNull(objectUnderTest.accessorStatement)
            Assert.NotNull(objectUnderTest.endAccessorStatement)
            Dim withObj = objectUnderTest.WithAccessorStatement(objectUnderTest.AccessorStatement).WithStatements(objectUnderTest.Statements).WithEndAccessorStatement(objectUnderTest.EndAccessorStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAddHandlerAccessorBlock()
            dim objectUnderTest = GenerateRedAddHandlerAccessorBlock()
            Assert.NotNull(objectUnderTest.accessorStatement)
            Assert.NotNull(objectUnderTest.endAccessorStatement)
            Dim withObj = objectUnderTest.WithAccessorStatement(objectUnderTest.AccessorStatement).WithStatements(objectUnderTest.Statements).WithEndAccessorStatement(objectUnderTest.EndAccessorStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRemoveHandlerAccessorBlock()
            dim objectUnderTest = GenerateRedRemoveHandlerAccessorBlock()
            Assert.NotNull(objectUnderTest.accessorStatement)
            Assert.NotNull(objectUnderTest.endAccessorStatement)
            Dim withObj = objectUnderTest.WithAccessorStatement(objectUnderTest.AccessorStatement).WithStatements(objectUnderTest.Statements).WithEndAccessorStatement(objectUnderTest.EndAccessorStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRaiseEventAccessorBlock()
            dim objectUnderTest = GenerateRedRaiseEventAccessorBlock()
            Assert.NotNull(objectUnderTest.accessorStatement)
            Assert.NotNull(objectUnderTest.endAccessorStatement)
            Dim withObj = objectUnderTest.WithAccessorStatement(objectUnderTest.AccessorStatement).WithStatements(objectUnderTest.Statements).WithEndAccessorStatement(objectUnderTest.EndAccessorStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedPropertyBlock()
            dim objectUnderTest = GenerateRedPropertyBlock()
            Assert.NotNull(objectUnderTest.propertyStatement)
            Assert.NotNull(objectUnderTest.accessors)
            Assert.NotNull(objectUnderTest.endPropertyStatement)
            Dim withObj = objectUnderTest.WithPropertyStatement(objectUnderTest.PropertyStatement).WithAccessors(objectUnderTest.Accessors).WithEndPropertyStatement(objectUnderTest.EndPropertyStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEventBlock()
            dim objectUnderTest = GenerateRedEventBlock()
            Assert.NotNull(objectUnderTest.eventStatement)
            Assert.NotNull(objectUnderTest.accessors)
            Assert.NotNull(objectUnderTest.endEventStatement)
            Dim withObj = objectUnderTest.WithEventStatement(objectUnderTest.EventStatement).WithAccessors(objectUnderTest.Accessors).WithEndEventStatement(objectUnderTest.EndEventStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedParameterList()
            dim objectUnderTest = GenerateRedParameterList()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithParameters(objectUnderTest.Parameters).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSubStatement()
            dim objectUnderTest = GenerateRedSubStatement()
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause).WithHandlesClause(objectUnderTest.HandlesClause).WithImplementsClause(objectUnderTest.ImplementsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionStatement()
            dim objectUnderTest = GenerateRedFunctionStatement()
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause).WithHandlesClause(objectUnderTest.HandlesClause).WithImplementsClause(objectUnderTest.ImplementsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSubNewStatement()
            dim objectUnderTest = GenerateRedSubNewStatement()
            Assert.NotNull(objectUnderTest.subKeyword)
            Assert.NotNull(objectUnderTest.newKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithSubKeyword(objectUnderTest.SubKeyword).WithNewKeyword(objectUnderTest.NewKeyword).WithParameterList(objectUnderTest.ParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDeclareSubStatement()
            dim objectUnderTest = GenerateRedDeclareSubStatement()
            Assert.NotNull(objectUnderTest.declareKeyword)
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Assert.NotNull(objectUnderTest.libKeyword)
            Assert.NotNull(objectUnderTest.libraryName)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithDeclareKeyword(objectUnderTest.DeclareKeyword).WithCharsetKeyword(objectUnderTest.CharsetKeyword).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithIdentifier(objectUnderTest.Identifier).WithLibKeyword(objectUnderTest.LibKeyword).WithLibraryName(objectUnderTest.LibraryName).WithAliasKeyword(objectUnderTest.AliasKeyword).WithAliasName(objectUnderTest.AliasName).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDeclareFunctionStatement()
            dim objectUnderTest = GenerateRedDeclareFunctionStatement()
            Assert.NotNull(objectUnderTest.declareKeyword)
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Assert.NotNull(objectUnderTest.libKeyword)
            Assert.NotNull(objectUnderTest.libraryName)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithDeclareKeyword(objectUnderTest.DeclareKeyword).WithCharsetKeyword(objectUnderTest.CharsetKeyword).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithIdentifier(objectUnderTest.Identifier).WithLibKeyword(objectUnderTest.LibKeyword).WithLibraryName(objectUnderTest.LibraryName).WithAliasKeyword(objectUnderTest.AliasKeyword).WithAliasName(objectUnderTest.AliasName).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDelegateSubStatement()
            dim objectUnderTest = GenerateRedDelegateSubStatement()
            Assert.NotNull(objectUnderTest.delegateKeyword)
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithDelegateKeyword(objectUnderTest.DelegateKeyword).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDelegateFunctionStatement()
            dim objectUnderTest = GenerateRedDelegateFunctionStatement()
            Assert.NotNull(objectUnderTest.delegateKeyword)
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithDelegateKeyword(objectUnderTest.DelegateKeyword).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithIdentifier(objectUnderTest.Identifier).WithTypeParameterList(objectUnderTest.TypeParameterList).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEventStatement()
            dim objectUnderTest = GenerateRedEventStatement()
            Assert.NotNull(objectUnderTest.eventKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithCustomKeyword(objectUnderTest.CustomKeyword).WithEventKeyword(objectUnderTest.EventKeyword).WithIdentifier(objectUnderTest.Identifier).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause).WithImplementsClause(objectUnderTest.ImplementsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOperatorStatement()
            dim objectUnderTest = GenerateRedOperatorStatement()
            Assert.NotNull(objectUnderTest.operatorKeyword)
            Assert.NotNull(objectUnderTest.operatorToken)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithOperatorKeyword(objectUnderTest.OperatorKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedPropertyStatement()
            dim objectUnderTest = GenerateRedPropertyStatement()
            Assert.NotNull(objectUnderTest.propertyKeyword)
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithPropertyKeyword(objectUnderTest.PropertyKeyword).WithIdentifier(objectUnderTest.Identifier).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause).WithInitializer(objectUnderTest.Initializer).WithImplementsClause(objectUnderTest.ImplementsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGetAccessorStatement()
            dim objectUnderTest = GenerateRedGetAccessorStatement()
            Assert.NotNull(objectUnderTest.accessorKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithAccessorKeyword(objectUnderTest.AccessorKeyword).WithParameterList(objectUnderTest.ParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSetAccessorStatement()
            dim objectUnderTest = GenerateRedSetAccessorStatement()
            Assert.NotNull(objectUnderTest.accessorKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithAccessorKeyword(objectUnderTest.AccessorKeyword).WithParameterList(objectUnderTest.ParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAddHandlerAccessorStatement()
            dim objectUnderTest = GenerateRedAddHandlerAccessorStatement()
            Assert.NotNull(objectUnderTest.accessorKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithAccessorKeyword(objectUnderTest.AccessorKeyword).WithParameterList(objectUnderTest.ParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRemoveHandlerAccessorStatement()
            dim objectUnderTest = GenerateRedRemoveHandlerAccessorStatement()
            Assert.NotNull(objectUnderTest.accessorKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithAccessorKeyword(objectUnderTest.AccessorKeyword).WithParameterList(objectUnderTest.ParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRaiseEventAccessorStatement()
            dim objectUnderTest = GenerateRedRaiseEventAccessorStatement()
            Assert.NotNull(objectUnderTest.accessorKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithAccessorKeyword(objectUnderTest.AccessorKeyword).WithParameterList(objectUnderTest.ParameterList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedImplementsClause()
            dim objectUnderTest = GenerateRedImplementsClause()
            Assert.NotNull(objectUnderTest.implementsKeyword)
            Assert.NotNull(objectUnderTest.interfaceMembers)
            Dim withObj = objectUnderTest.WithImplementsKeyword(objectUnderTest.ImplementsKeyword).WithInterfaceMembers(objectUnderTest.InterfaceMembers)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedHandlesClause()
            dim objectUnderTest = GenerateRedHandlesClause()
            Assert.NotNull(objectUnderTest.handlesKeyword)
            Assert.NotNull(objectUnderTest.events)
            Dim withObj = objectUnderTest.WithHandlesKeyword(objectUnderTest.HandlesKeyword).WithEvents(objectUnderTest.Events)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedKeywordEventContainer()
            dim objectUnderTest = GenerateRedKeywordEventContainer()
            Assert.NotNull(objectUnderTest.keyword)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWithEventsEventContainer()
            dim objectUnderTest = GenerateRedWithEventsEventContainer()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWithEventsPropertyEventContainer()
            dim objectUnderTest = GenerateRedWithEventsPropertyEventContainer()
            Assert.NotNull(objectUnderTest.withEventsContainer)
            Assert.NotNull(objectUnderTest.dotToken)
            Assert.NotNull(objectUnderTest.property)
            Dim withObj = objectUnderTest.WithWithEventsContainer(objectUnderTest.WithEventsContainer).WithDotToken(objectUnderTest.DotToken).WithProperty(objectUnderTest.Property)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedHandlesClauseItem()
            dim objectUnderTest = GenerateRedHandlesClauseItem()
            Assert.NotNull(objectUnderTest.eventContainer)
            Assert.NotNull(objectUnderTest.dotToken)
            Assert.NotNull(objectUnderTest.eventMember)
            Dim withObj = objectUnderTest.WithEventContainer(objectUnderTest.EventContainer).WithDotToken(objectUnderTest.DotToken).WithEventMember(objectUnderTest.EventMember)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIncompleteMember()
            dim objectUnderTest = GenerateRedIncompleteMember()
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithMissingIdentifier(objectUnderTest.MissingIdentifier)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFieldDeclaration()
            dim objectUnderTest = GenerateRedFieldDeclaration()
            Assert.NotNull(objectUnderTest.declarators)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithDeclarators(objectUnderTest.Declarators)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedVariableDeclarator()
            dim objectUnderTest = GenerateRedVariableDeclarator()
            Assert.NotNull(objectUnderTest.names)
            Dim withObj = objectUnderTest.WithNames(objectUnderTest.Names).WithAsClause(objectUnderTest.AsClause).WithInitializer(objectUnderTest.Initializer)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleAsClause()
            dim objectUnderTest = GenerateRedSimpleAsClause()
            Assert.NotNull(objectUnderTest.asKeyword)
            Assert.NotNull(objectUnderTest.type)
            Dim withObj = objectUnderTest.WithAsKeyword(objectUnderTest.AsKeyword).WithAttributeLists(objectUnderTest.AttributeLists).WithType(objectUnderTest.Type)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAsNewClause()
            dim objectUnderTest = GenerateRedAsNewClause()
            Assert.NotNull(objectUnderTest.asKeyword)
            Assert.NotNull(objectUnderTest.newExpression)
            Dim withObj = objectUnderTest.WithAsKeyword(objectUnderTest.AsKeyword).WithNewExpression(objectUnderTest.NewExpression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedObjectMemberInitializer()
            dim objectUnderTest = GenerateRedObjectMemberInitializer()
            Assert.NotNull(objectUnderTest.withKeyword)
            Assert.NotNull(objectUnderTest.openBraceToken)
            Assert.NotNull(objectUnderTest.initializers)
            Assert.NotNull(objectUnderTest.closeBraceToken)
            Dim withObj = objectUnderTest.WithWithKeyword(objectUnderTest.WithKeyword).WithOpenBraceToken(objectUnderTest.OpenBraceToken).WithInitializers(objectUnderTest.Initializers).WithCloseBraceToken(objectUnderTest.CloseBraceToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedObjectCollectionInitializer()
            dim objectUnderTest = GenerateRedObjectCollectionInitializer()
            Assert.NotNull(objectUnderTest.fromKeyword)
            Assert.NotNull(objectUnderTest.initializer)
            Dim withObj = objectUnderTest.WithFromKeyword(objectUnderTest.FromKeyword).WithInitializer(objectUnderTest.Initializer)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInferredFieldInitializer()
            dim objectUnderTest = GenerateRedInferredFieldInitializer()
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithKeyKeyword(objectUnderTest.KeyKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNamedFieldInitializer()
            dim objectUnderTest = GenerateRedNamedFieldInitializer()
            Assert.NotNull(objectUnderTest.dotToken)
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithKeyKeyword(objectUnderTest.KeyKeyword).WithDotToken(objectUnderTest.DotToken).WithName(objectUnderTest.Name).WithEqualsToken(objectUnderTest.EqualsToken).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEqualsValue()
            dim objectUnderTest = GenerateRedEqualsValue()
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithEqualsToken(objectUnderTest.EqualsToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedParameter()
            dim objectUnderTest = GenerateRedParameter()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithIdentifier(objectUnderTest.Identifier).WithAsClause(objectUnderTest.AsClause).WithDefault(objectUnderTest.Default)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedModifiedIdentifier()
            dim objectUnderTest = GenerateRedModifiedIdentifier()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier).WithNullable(objectUnderTest.Nullable).WithArrayBounds(objectUnderTest.ArrayBounds).WithArrayRankSpecifiers(objectUnderTest.ArrayRankSpecifiers)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedArrayRankSpecifier()
            dim objectUnderTest = GenerateRedArrayRankSpecifier()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithCommaTokens(objectUnderTest.CommaTokens).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributeList()
            dim objectUnderTest = GenerateRedAttributeList()
            Assert.NotNull(objectUnderTest.lessThanToken)
            Assert.NotNull(objectUnderTest.greaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanToken(objectUnderTest.LessThanToken).WithAttributes(objectUnderTest.Attributes).WithGreaterThanToken(objectUnderTest.GreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAttribute()
            dim objectUnderTest = GenerateRedAttribute()
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithTarget(objectUnderTest.Target).WithName(objectUnderTest.Name).WithArgumentList(objectUnderTest.ArgumentList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributeTarget()
            dim objectUnderTest = GenerateRedAttributeTarget()
            Assert.NotNull(objectUnderTest.attributeModifier)
            Assert.NotNull(objectUnderTest.colonToken)
            Dim withObj = objectUnderTest.WithAttributeModifier(objectUnderTest.AttributeModifier).WithColonToken(objectUnderTest.ColonToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributesStatement()
            dim objectUnderTest = GenerateRedAttributesStatement()
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExpressionStatement()
            dim objectUnderTest = GenerateRedExpressionStatement()
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedPrintStatement()
            dim objectUnderTest = GenerateRedPrintStatement()
            Assert.NotNull(objectUnderTest.questionToken)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithQuestionToken(objectUnderTest.QuestionToken).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWhileBlock()
            dim objectUnderTest = GenerateRedWhileBlock()
            Assert.NotNull(objectUnderTest.whileStatement)
            Assert.NotNull(objectUnderTest.endWhileStatement)
            Dim withObj = objectUnderTest.WithWhileStatement(objectUnderTest.WhileStatement).WithStatements(objectUnderTest.Statements).WithEndWhileStatement(objectUnderTest.EndWhileStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedUsingBlock()
            dim objectUnderTest = GenerateRedUsingBlock()
            Assert.NotNull(objectUnderTest.usingStatement)
            Assert.NotNull(objectUnderTest.endUsingStatement)
            Dim withObj = objectUnderTest.WithUsingStatement(objectUnderTest.UsingStatement).WithStatements(objectUnderTest.Statements).WithEndUsingStatement(objectUnderTest.EndUsingStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSyncLockBlock()
            dim objectUnderTest = GenerateRedSyncLockBlock()
            Assert.NotNull(objectUnderTest.syncLockStatement)
            Assert.NotNull(objectUnderTest.endSyncLockStatement)
            Dim withObj = objectUnderTest.WithSyncLockStatement(objectUnderTest.SyncLockStatement).WithStatements(objectUnderTest.Statements).WithEndSyncLockStatement(objectUnderTest.EndSyncLockStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWithBlock()
            dim objectUnderTest = GenerateRedWithBlock()
            Assert.NotNull(objectUnderTest.withStatement)
            Assert.NotNull(objectUnderTest.endWithStatement)
            Dim withObj = objectUnderTest.WithWithStatement(objectUnderTest.WithStatement).WithStatements(objectUnderTest.Statements).WithEndWithStatement(objectUnderTest.EndWithStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLocalDeclarationStatement()
            dim objectUnderTest = GenerateRedLocalDeclarationStatement()
            Assert.NotNull(objectUnderTest.modifiers)
            Assert.NotNull(objectUnderTest.declarators)
            Dim withObj = objectUnderTest.WithModifiers(objectUnderTest.Modifiers).WithDeclarators(objectUnderTest.Declarators)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLabelStatement()
            dim objectUnderTest = GenerateRedLabelStatement()
            Assert.NotNull(objectUnderTest.labelToken)
            Assert.NotNull(objectUnderTest.colonToken)
            Dim withObj = objectUnderTest.WithLabelToken(objectUnderTest.LabelToken).WithColonToken(objectUnderTest.ColonToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGoToStatement()
            dim objectUnderTest = GenerateRedGoToStatement()
            Assert.NotNull(objectUnderTest.goToKeyword)
            Assert.NotNull(objectUnderTest.label)
            Dim withObj = objectUnderTest.WithGoToKeyword(objectUnderTest.GoToKeyword).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIdentifierLabel()
            dim objectUnderTest = GenerateRedIdentifierLabel()
            Assert.NotNull(objectUnderTest.labelToken)
            Dim withObj = objectUnderTest.WithLabelToken(objectUnderTest.LabelToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNumericLabel()
            dim objectUnderTest = GenerateRedNumericLabel()
            Assert.NotNull(objectUnderTest.labelToken)
            Dim withObj = objectUnderTest.WithLabelToken(objectUnderTest.LabelToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNextLabel()
            dim objectUnderTest = GenerateRedNextLabel()
            Assert.NotNull(objectUnderTest.labelToken)
            Dim withObj = objectUnderTest.WithLabelToken(objectUnderTest.LabelToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedStopStatement()
            dim objectUnderTest = GenerateRedStopStatement()
            Assert.NotNull(objectUnderTest.stopOrEndKeyword)
            Dim withObj = objectUnderTest.WithStopOrEndKeyword(objectUnderTest.StopOrEndKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndStatement()
            dim objectUnderTest = GenerateRedEndStatement()
            Assert.NotNull(objectUnderTest.stopOrEndKeyword)
            Dim withObj = objectUnderTest.WithStopOrEndKeyword(objectUnderTest.StopOrEndKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitDoStatement()
            dim objectUnderTest = GenerateRedExitDoStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitForStatement()
            dim objectUnderTest = GenerateRedExitForStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitSubStatement()
            dim objectUnderTest = GenerateRedExitSubStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitFunctionStatement()
            dim objectUnderTest = GenerateRedExitFunctionStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitOperatorStatement()
            dim objectUnderTest = GenerateRedExitOperatorStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitPropertyStatement()
            dim objectUnderTest = GenerateRedExitPropertyStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitTryStatement()
            dim objectUnderTest = GenerateRedExitTryStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitSelectStatement()
            dim objectUnderTest = GenerateRedExitSelectStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExitWhileStatement()
            dim objectUnderTest = GenerateRedExitWhileStatement()
            Assert.NotNull(objectUnderTest.exitKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithExitKeyword(objectUnderTest.ExitKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedContinueWhileStatement()
            dim objectUnderTest = GenerateRedContinueWhileStatement()
            Assert.NotNull(objectUnderTest.continueKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithContinueKeyword(objectUnderTest.ContinueKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedContinueDoStatement()
            dim objectUnderTest = GenerateRedContinueDoStatement()
            Assert.NotNull(objectUnderTest.continueKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithContinueKeyword(objectUnderTest.ContinueKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedContinueForStatement()
            dim objectUnderTest = GenerateRedContinueForStatement()
            Assert.NotNull(objectUnderTest.continueKeyword)
            Assert.NotNull(objectUnderTest.blockKeyword)
            Dim withObj = objectUnderTest.WithContinueKeyword(objectUnderTest.ContinueKeyword).WithBlockKeyword(objectUnderTest.BlockKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedReturnStatement()
            dim objectUnderTest = GenerateRedReturnStatement()
            Assert.NotNull(objectUnderTest.returnKeyword)
            Dim withObj = objectUnderTest.WithReturnKeyword(objectUnderTest.ReturnKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineIfStatement()
            dim objectUnderTest = GenerateRedSingleLineIfStatement()
            Assert.NotNull(objectUnderTest.ifKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Assert.NotNull(objectUnderTest.thenKeyword)
            Dim withObj = objectUnderTest.WithIfKeyword(objectUnderTest.IfKeyword).WithCondition(objectUnderTest.Condition).WithThenKeyword(objectUnderTest.ThenKeyword).WithStatements(objectUnderTest.Statements).WithElseClause(objectUnderTest.ElseClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineElseClause()
            dim objectUnderTest = GenerateRedSingleLineElseClause()
            Assert.NotNull(objectUnderTest.elseKeyword)
            Dim withObj = objectUnderTest.WithElseKeyword(objectUnderTest.ElseKeyword).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiLineIfBlock()
            dim objectUnderTest = GenerateRedMultiLineIfBlock()
            Assert.NotNull(objectUnderTest.ifStatement)
            Assert.NotNull(objectUnderTest.endIfStatement)
            Dim withObj = objectUnderTest.WithIfStatement(objectUnderTest.IfStatement).WithStatements(objectUnderTest.Statements).WithElseIfBlocks(objectUnderTest.ElseIfBlocks).WithElseBlock(objectUnderTest.ElseBlock).WithEndIfStatement(objectUnderTest.EndIfStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIfStatement()
            dim objectUnderTest = GenerateRedIfStatement()
            Assert.NotNull(objectUnderTest.ifKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithIfKeyword(objectUnderTest.IfKeyword).WithCondition(objectUnderTest.Condition).WithThenKeyword(objectUnderTest.ThenKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseIfBlock()
            dim objectUnderTest = GenerateRedElseIfBlock()
            Assert.NotNull(objectUnderTest.elseIfStatement)
            Dim withObj = objectUnderTest.WithElseIfStatement(objectUnderTest.ElseIfStatement).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseIfStatement()
            dim objectUnderTest = GenerateRedElseIfStatement()
            Assert.NotNull(objectUnderTest.elseIfKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithElseIfKeyword(objectUnderTest.ElseIfKeyword).WithCondition(objectUnderTest.Condition).WithThenKeyword(objectUnderTest.ThenKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseBlock()
            dim objectUnderTest = GenerateRedElseBlock()
            Assert.NotNull(objectUnderTest.elseStatement)
            Dim withObj = objectUnderTest.WithElseStatement(objectUnderTest.ElseStatement).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseStatement()
            dim objectUnderTest = GenerateRedElseStatement()
            Assert.NotNull(objectUnderTest.elseKeyword)
            Dim withObj = objectUnderTest.WithElseKeyword(objectUnderTest.ElseKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTryBlock()
            dim objectUnderTest = GenerateRedTryBlock()
            Assert.NotNull(objectUnderTest.tryStatement)
            Assert.NotNull(objectUnderTest.endTryStatement)
            Dim withObj = objectUnderTest.WithTryStatement(objectUnderTest.TryStatement).WithStatements(objectUnderTest.Statements).WithCatchBlocks(objectUnderTest.CatchBlocks).WithFinallyBlock(objectUnderTest.FinallyBlock).WithEndTryStatement(objectUnderTest.EndTryStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTryStatement()
            dim objectUnderTest = GenerateRedTryStatement()
            Assert.NotNull(objectUnderTest.tryKeyword)
            Dim withObj = objectUnderTest.WithTryKeyword(objectUnderTest.TryKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCatchBlock()
            dim objectUnderTest = GenerateRedCatchBlock()
            Assert.NotNull(objectUnderTest.catchStatement)
            Dim withObj = objectUnderTest.WithCatchStatement(objectUnderTest.CatchStatement).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCatchStatement()
            dim objectUnderTest = GenerateRedCatchStatement()
            Assert.NotNull(objectUnderTest.catchKeyword)
            Dim withObj = objectUnderTest.WithCatchKeyword(objectUnderTest.CatchKeyword).WithIdentifierName(objectUnderTest.IdentifierName).WithAsClause(objectUnderTest.AsClause).WithWhenClause(objectUnderTest.WhenClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCatchFilterClause()
            dim objectUnderTest = GenerateRedCatchFilterClause()
            Assert.NotNull(objectUnderTest.whenKeyword)
            Assert.NotNull(objectUnderTest.filter)
            Dim withObj = objectUnderTest.WithWhenKeyword(objectUnderTest.WhenKeyword).WithFilter(objectUnderTest.Filter)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFinallyBlock()
            dim objectUnderTest = GenerateRedFinallyBlock()
            Assert.NotNull(objectUnderTest.finallyStatement)
            Dim withObj = objectUnderTest.WithFinallyStatement(objectUnderTest.FinallyStatement).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFinallyStatement()
            dim objectUnderTest = GenerateRedFinallyStatement()
            Assert.NotNull(objectUnderTest.finallyKeyword)
            Dim withObj = objectUnderTest.WithFinallyKeyword(objectUnderTest.FinallyKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedErrorStatement()
            dim objectUnderTest = GenerateRedErrorStatement()
            Assert.NotNull(objectUnderTest.errorKeyword)
            Assert.NotNull(objectUnderTest.errorNumber)
            Dim withObj = objectUnderTest.WithErrorKeyword(objectUnderTest.ErrorKeyword).WithErrorNumber(objectUnderTest.ErrorNumber)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorGoToZeroStatement()
            dim objectUnderTest = GenerateRedOnErrorGoToZeroStatement()
            Assert.NotNull(objectUnderTest.onKeyword)
            Assert.NotNull(objectUnderTest.errorKeyword)
            Assert.NotNull(objectUnderTest.goToKeyword)
            Assert.NotNull(objectUnderTest.label)
            Dim withObj = objectUnderTest.WithOnKeyword(objectUnderTest.OnKeyword).WithErrorKeyword(objectUnderTest.ErrorKeyword).WithGoToKeyword(objectUnderTest.GoToKeyword).WithMinus(objectUnderTest.Minus).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorGoToMinusOneStatement()
            dim objectUnderTest = GenerateRedOnErrorGoToMinusOneStatement()
            Assert.NotNull(objectUnderTest.onKeyword)
            Assert.NotNull(objectUnderTest.errorKeyword)
            Assert.NotNull(objectUnderTest.goToKeyword)
            Assert.NotNull(objectUnderTest.label)
            Dim withObj = objectUnderTest.WithOnKeyword(objectUnderTest.OnKeyword).WithErrorKeyword(objectUnderTest.ErrorKeyword).WithGoToKeyword(objectUnderTest.GoToKeyword).WithMinus(objectUnderTest.Minus).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorGoToLabelStatement()
            dim objectUnderTest = GenerateRedOnErrorGoToLabelStatement()
            Assert.NotNull(objectUnderTest.onKeyword)
            Assert.NotNull(objectUnderTest.errorKeyword)
            Assert.NotNull(objectUnderTest.goToKeyword)
            Assert.NotNull(objectUnderTest.label)
            Dim withObj = objectUnderTest.WithOnKeyword(objectUnderTest.OnKeyword).WithErrorKeyword(objectUnderTest.ErrorKeyword).WithGoToKeyword(objectUnderTest.GoToKeyword).WithMinus(objectUnderTest.Minus).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorResumeNextStatement()
            dim objectUnderTest = GenerateRedOnErrorResumeNextStatement()
            Assert.NotNull(objectUnderTest.onKeyword)
            Assert.NotNull(objectUnderTest.errorKeyword)
            Assert.NotNull(objectUnderTest.resumeKeyword)
            Assert.NotNull(objectUnderTest.nextKeyword)
            Dim withObj = objectUnderTest.WithOnKeyword(objectUnderTest.OnKeyword).WithErrorKeyword(objectUnderTest.ErrorKeyword).WithResumeKeyword(objectUnderTest.ResumeKeyword).WithNextKeyword(objectUnderTest.NextKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedResumeStatement()
            dim objectUnderTest = GenerateRedResumeStatement()
            Assert.NotNull(objectUnderTest.resumeKeyword)
            Dim withObj = objectUnderTest.WithResumeKeyword(objectUnderTest.ResumeKeyword).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedResumeLabelStatement()
            dim objectUnderTest = GenerateRedResumeLabelStatement()
            Assert.NotNull(objectUnderTest.resumeKeyword)
            Dim withObj = objectUnderTest.WithResumeKeyword(objectUnderTest.ResumeKeyword).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedResumeNextStatement()
            dim objectUnderTest = GenerateRedResumeNextStatement()
            Assert.NotNull(objectUnderTest.resumeKeyword)
            Dim withObj = objectUnderTest.WithResumeKeyword(objectUnderTest.ResumeKeyword).WithLabel(objectUnderTest.Label)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSelectBlock()
            dim objectUnderTest = GenerateRedSelectBlock()
            Assert.NotNull(objectUnderTest.selectStatement)
            Assert.NotNull(objectUnderTest.endSelectStatement)
            Dim withObj = objectUnderTest.WithSelectStatement(objectUnderTest.SelectStatement).WithCaseBlocks(objectUnderTest.CaseBlocks).WithEndSelectStatement(objectUnderTest.EndSelectStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSelectStatement()
            dim objectUnderTest = GenerateRedSelectStatement()
            Assert.NotNull(objectUnderTest.selectKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithSelectKeyword(objectUnderTest.SelectKeyword).WithCaseKeyword(objectUnderTest.CaseKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseBlock()
            dim objectUnderTest = GenerateRedCaseBlock()
            Assert.NotNull(objectUnderTest.caseStatement)
            Dim withObj = objectUnderTest.WithCaseStatement(objectUnderTest.CaseStatement).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseElseBlock()
            dim objectUnderTest = GenerateRedCaseElseBlock()
            Assert.NotNull(objectUnderTest.caseStatement)
            Dim withObj = objectUnderTest.WithCaseStatement(objectUnderTest.CaseStatement).WithStatements(objectUnderTest.Statements)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseStatement()
            dim objectUnderTest = GenerateRedCaseStatement()
            Assert.NotNull(objectUnderTest.caseKeyword)
            Assert.NotNull(objectUnderTest.cases)
            Dim withObj = objectUnderTest.WithCaseKeyword(objectUnderTest.CaseKeyword).WithCases(objectUnderTest.Cases)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseElseStatement()
            dim objectUnderTest = GenerateRedCaseElseStatement()
            Assert.NotNull(objectUnderTest.caseKeyword)
            Assert.NotNull(objectUnderTest.cases)
            Dim withObj = objectUnderTest.WithCaseKeyword(objectUnderTest.CaseKeyword).WithCases(objectUnderTest.Cases)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseCaseClause()
            dim objectUnderTest = GenerateRedElseCaseClause()
            Assert.NotNull(objectUnderTest.elseKeyword)
            Dim withObj = objectUnderTest.WithElseKeyword(objectUnderTest.ElseKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleCaseClause()
            dim objectUnderTest = GenerateRedSimpleCaseClause()
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRangeCaseClause()
            dim objectUnderTest = GenerateRedRangeCaseClause()
            Assert.NotNull(objectUnderTest.lowerBound)
            Assert.NotNull(objectUnderTest.toKeyword)
            Assert.NotNull(objectUnderTest.upperBound)
            Dim withObj = objectUnderTest.WithLowerBound(objectUnderTest.LowerBound).WithToKeyword(objectUnderTest.ToKeyword).WithUpperBound(objectUnderTest.UpperBound)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseEqualsClause()
            dim objectUnderTest = GenerateRedCaseEqualsClause()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithIsKeyword(objectUnderTest.IsKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseNotEqualsClause()
            dim objectUnderTest = GenerateRedCaseNotEqualsClause()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithIsKeyword(objectUnderTest.IsKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseLessThanClause()
            dim objectUnderTest = GenerateRedCaseLessThanClause()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithIsKeyword(objectUnderTest.IsKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseLessThanOrEqualClause()
            dim objectUnderTest = GenerateRedCaseLessThanOrEqualClause()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithIsKeyword(objectUnderTest.IsKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseGreaterThanOrEqualClause()
            dim objectUnderTest = GenerateRedCaseGreaterThanOrEqualClause()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithIsKeyword(objectUnderTest.IsKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseGreaterThanClause()
            dim objectUnderTest = GenerateRedCaseGreaterThanClause()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithIsKeyword(objectUnderTest.IsKeyword).WithOperatorToken(objectUnderTest.OperatorToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSyncLockStatement()
            dim objectUnderTest = GenerateRedSyncLockStatement()
            Assert.NotNull(objectUnderTest.syncLockKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithSyncLockKeyword(objectUnderTest.SyncLockKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleDoLoopBlock()
            dim objectUnderTest = GenerateRedSimpleDoLoopBlock()
            Assert.NotNull(objectUnderTest.doStatement)
            Assert.NotNull(objectUnderTest.loopStatement)
            Dim withObj = objectUnderTest.WithDoStatement(objectUnderTest.DoStatement).WithStatements(objectUnderTest.Statements).WithLoopStatement(objectUnderTest.LoopStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDoWhileLoopBlock()
            dim objectUnderTest = GenerateRedDoWhileLoopBlock()
            Assert.NotNull(objectUnderTest.doStatement)
            Assert.NotNull(objectUnderTest.loopStatement)
            Dim withObj = objectUnderTest.WithDoStatement(objectUnderTest.DoStatement).WithStatements(objectUnderTest.Statements).WithLoopStatement(objectUnderTest.LoopStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDoUntilLoopBlock()
            dim objectUnderTest = GenerateRedDoUntilLoopBlock()
            Assert.NotNull(objectUnderTest.doStatement)
            Assert.NotNull(objectUnderTest.loopStatement)
            Dim withObj = objectUnderTest.WithDoStatement(objectUnderTest.DoStatement).WithStatements(objectUnderTest.Statements).WithLoopStatement(objectUnderTest.LoopStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDoLoopWhileBlock()
            dim objectUnderTest = GenerateRedDoLoopWhileBlock()
            Assert.NotNull(objectUnderTest.doStatement)
            Assert.NotNull(objectUnderTest.loopStatement)
            Dim withObj = objectUnderTest.WithDoStatement(objectUnderTest.DoStatement).WithStatements(objectUnderTest.Statements).WithLoopStatement(objectUnderTest.LoopStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDoLoopUntilBlock()
            dim objectUnderTest = GenerateRedDoLoopUntilBlock()
            Assert.NotNull(objectUnderTest.doStatement)
            Assert.NotNull(objectUnderTest.loopStatement)
            Dim withObj = objectUnderTest.WithDoStatement(objectUnderTest.DoStatement).WithStatements(objectUnderTest.Statements).WithLoopStatement(objectUnderTest.LoopStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleDoStatement()
            dim objectUnderTest = GenerateRedSimpleDoStatement()
            Assert.NotNull(objectUnderTest.doKeyword)
            Dim withObj = objectUnderTest.WithDoKeyword(objectUnderTest.DoKeyword).WithWhileOrUntilClause(objectUnderTest.WhileOrUntilClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDoWhileStatement()
            dim objectUnderTest = GenerateRedDoWhileStatement()
            Assert.NotNull(objectUnderTest.doKeyword)
            Dim withObj = objectUnderTest.WithDoKeyword(objectUnderTest.DoKeyword).WithWhileOrUntilClause(objectUnderTest.WhileOrUntilClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDoUntilStatement()
            dim objectUnderTest = GenerateRedDoUntilStatement()
            Assert.NotNull(objectUnderTest.doKeyword)
            Dim withObj = objectUnderTest.WithDoKeyword(objectUnderTest.DoKeyword).WithWhileOrUntilClause(objectUnderTest.WhileOrUntilClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleLoopStatement()
            dim objectUnderTest = GenerateRedSimpleLoopStatement()
            Assert.NotNull(objectUnderTest.loopKeyword)
            Dim withObj = objectUnderTest.WithLoopKeyword(objectUnderTest.LoopKeyword).WithWhileOrUntilClause(objectUnderTest.WhileOrUntilClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLoopWhileStatement()
            dim objectUnderTest = GenerateRedLoopWhileStatement()
            Assert.NotNull(objectUnderTest.loopKeyword)
            Dim withObj = objectUnderTest.WithLoopKeyword(objectUnderTest.LoopKeyword).WithWhileOrUntilClause(objectUnderTest.WhileOrUntilClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLoopUntilStatement()
            dim objectUnderTest = GenerateRedLoopUntilStatement()
            Assert.NotNull(objectUnderTest.loopKeyword)
            Dim withObj = objectUnderTest.WithLoopKeyword(objectUnderTest.LoopKeyword).WithWhileOrUntilClause(objectUnderTest.WhileOrUntilClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWhileClause()
            dim objectUnderTest = GenerateRedWhileClause()
            Assert.NotNull(objectUnderTest.whileOrUntilKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithWhileOrUntilKeyword(objectUnderTest.WhileOrUntilKeyword).WithCondition(objectUnderTest.Condition)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedUntilClause()
            dim objectUnderTest = GenerateRedUntilClause()
            Assert.NotNull(objectUnderTest.whileOrUntilKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithWhileOrUntilKeyword(objectUnderTest.WhileOrUntilKeyword).WithCondition(objectUnderTest.Condition)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWhileStatement()
            dim objectUnderTest = GenerateRedWhileStatement()
            Assert.NotNull(objectUnderTest.whileKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithWhileKeyword(objectUnderTest.WhileKeyword).WithCondition(objectUnderTest.Condition)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedForBlock()
            dim objectUnderTest = GenerateRedForBlock()
            Assert.NotNull(objectUnderTest.forStatement)
            Dim withObj = objectUnderTest.WithForStatement(objectUnderTest.ForStatement).WithStatements(objectUnderTest.Statements).WithNextStatement(objectUnderTest.NextStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedForEachBlock()
            dim objectUnderTest = GenerateRedForEachBlock()
            Assert.NotNull(objectUnderTest.forEachStatement)
            Dim withObj = objectUnderTest.WithForEachStatement(objectUnderTest.ForEachStatement).WithStatements(objectUnderTest.Statements).WithNextStatement(objectUnderTest.NextStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedForStatement()
            dim objectUnderTest = GenerateRedForStatement()
            Assert.NotNull(objectUnderTest.forKeyword)
            Assert.NotNull(objectUnderTest.controlVariable)
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.fromValue)
            Assert.NotNull(objectUnderTest.toKeyword)
            Assert.NotNull(objectUnderTest.toValue)
            Dim withObj = objectUnderTest.WithForKeyword(objectUnderTest.ForKeyword).WithControlVariable(objectUnderTest.ControlVariable).WithEqualsToken(objectUnderTest.EqualsToken).WithFromValue(objectUnderTest.FromValue).WithToKeyword(objectUnderTest.ToKeyword).WithToValue(objectUnderTest.ToValue).WithStepClause(objectUnderTest.StepClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedForStepClause()
            dim objectUnderTest = GenerateRedForStepClause()
            Assert.NotNull(objectUnderTest.stepKeyword)
            Assert.NotNull(objectUnderTest.stepValue)
            Dim withObj = objectUnderTest.WithStepKeyword(objectUnderTest.StepKeyword).WithStepValue(objectUnderTest.StepValue)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedForEachStatement()
            dim objectUnderTest = GenerateRedForEachStatement()
            Assert.NotNull(objectUnderTest.forKeyword)
            Assert.NotNull(objectUnderTest.eachKeyword)
            Assert.NotNull(objectUnderTest.controlVariable)
            Assert.NotNull(objectUnderTest.inKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithForKeyword(objectUnderTest.ForKeyword).WithEachKeyword(objectUnderTest.EachKeyword).WithControlVariable(objectUnderTest.ControlVariable).WithInKeyword(objectUnderTest.InKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNextStatement()
            dim objectUnderTest = GenerateRedNextStatement()
            Assert.NotNull(objectUnderTest.nextKeyword)
            Dim withObj = objectUnderTest.WithNextKeyword(objectUnderTest.NextKeyword).WithControlVariables(objectUnderTest.ControlVariables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedUsingStatement()
            dim objectUnderTest = GenerateRedUsingStatement()
            Assert.NotNull(objectUnderTest.usingKeyword)
            Dim withObj = objectUnderTest.WithUsingKeyword(objectUnderTest.UsingKeyword).WithExpression(objectUnderTest.Expression).WithVariables(objectUnderTest.Variables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedThrowStatement()
            dim objectUnderTest = GenerateRedThrowStatement()
            Assert.NotNull(objectUnderTest.throwKeyword)
            Dim withObj = objectUnderTest.WithThrowKeyword(objectUnderTest.ThrowKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleAssignmentStatement()
            dim objectUnderTest = GenerateRedSimpleAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMidAssignmentStatement()
            dim objectUnderTest = GenerateRedMidAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAddAssignmentStatement()
            dim objectUnderTest = GenerateRedAddAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSubtractAssignmentStatement()
            dim objectUnderTest = GenerateRedSubtractAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiplyAssignmentStatement()
            dim objectUnderTest = GenerateRedMultiplyAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDivideAssignmentStatement()
            dim objectUnderTest = GenerateRedDivideAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIntegerDivideAssignmentStatement()
            dim objectUnderTest = GenerateRedIntegerDivideAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExponentiateAssignmentStatement()
            dim objectUnderTest = GenerateRedExponentiateAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLeftShiftAssignmentStatement()
            dim objectUnderTest = GenerateRedLeftShiftAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRightShiftAssignmentStatement()
            dim objectUnderTest = GenerateRedRightShiftAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedConcatenateAssignmentStatement()
            dim objectUnderTest = GenerateRedConcatenateAssignmentStatement()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMidExpression()
            dim objectUnderTest = GenerateRedMidExpression()
            Assert.NotNull(objectUnderTest.mid)
            Assert.NotNull(objectUnderTest.argumentList)
            Dim withObj = objectUnderTest.WithMid(objectUnderTest.Mid).WithArgumentList(objectUnderTest.ArgumentList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCallStatement()
            dim objectUnderTest = GenerateRedCallStatement()
            Assert.NotNull(objectUnderTest.callKeyword)
            Assert.NotNull(objectUnderTest.invocation)
            Dim withObj = objectUnderTest.WithCallKeyword(objectUnderTest.CallKeyword).WithInvocation(objectUnderTest.Invocation)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAddHandlerStatement()
            dim objectUnderTest = GenerateRedAddHandlerStatement()
            Assert.NotNull(objectUnderTest.addHandlerOrRemoveHandlerKeyword)
            Assert.NotNull(objectUnderTest.eventExpression)
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.delegateExpression)
            Dim withObj = objectUnderTest.WithAddHandlerOrRemoveHandlerKeyword(objectUnderTest.AddHandlerOrRemoveHandlerKeyword).WithEventExpression(objectUnderTest.EventExpression).WithCommaToken(objectUnderTest.CommaToken).WithDelegateExpression(objectUnderTest.DelegateExpression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRemoveHandlerStatement()
            dim objectUnderTest = GenerateRedRemoveHandlerStatement()
            Assert.NotNull(objectUnderTest.addHandlerOrRemoveHandlerKeyword)
            Assert.NotNull(objectUnderTest.eventExpression)
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.delegateExpression)
            Dim withObj = objectUnderTest.WithAddHandlerOrRemoveHandlerKeyword(objectUnderTest.AddHandlerOrRemoveHandlerKeyword).WithEventExpression(objectUnderTest.EventExpression).WithCommaToken(objectUnderTest.CommaToken).WithDelegateExpression(objectUnderTest.DelegateExpression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRaiseEventStatement()
            dim objectUnderTest = GenerateRedRaiseEventStatement()
            Assert.NotNull(objectUnderTest.raiseEventKeyword)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithRaiseEventKeyword(objectUnderTest.RaiseEventKeyword).WithName(objectUnderTest.Name).WithArgumentList(objectUnderTest.ArgumentList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWithStatement()
            dim objectUnderTest = GenerateRedWithStatement()
            Assert.NotNull(objectUnderTest.withKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithWithKeyword(objectUnderTest.WithKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedReDimStatement()
            dim objectUnderTest = GenerateRedReDimStatement()
            Assert.NotNull(objectUnderTest.reDimKeyword)
            Assert.NotNull(objectUnderTest.clauses)
            Dim withObj = objectUnderTest.WithReDimKeyword(objectUnderTest.ReDimKeyword).WithPreserveKeyword(objectUnderTest.PreserveKeyword).WithClauses(objectUnderTest.Clauses)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedReDimPreserveStatement()
            dim objectUnderTest = GenerateRedReDimPreserveStatement()
            Assert.NotNull(objectUnderTest.reDimKeyword)
            Assert.NotNull(objectUnderTest.clauses)
            Dim withObj = objectUnderTest.WithReDimKeyword(objectUnderTest.ReDimKeyword).WithPreserveKeyword(objectUnderTest.PreserveKeyword).WithClauses(objectUnderTest.Clauses)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRedimClause()
            dim objectUnderTest = GenerateRedRedimClause()
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.arrayBounds)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithArrayBounds(objectUnderTest.ArrayBounds)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEraseStatement()
            dim objectUnderTest = GenerateRedEraseStatement()
            Assert.NotNull(objectUnderTest.eraseKeyword)
            Assert.NotNull(objectUnderTest.expressions)
            Dim withObj = objectUnderTest.WithEraseKeyword(objectUnderTest.EraseKeyword).WithExpressions(objectUnderTest.Expressions)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCharacterLiteralExpression()
            dim objectUnderTest = GenerateRedCharacterLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTrueLiteralExpression()
            dim objectUnderTest = GenerateRedTrueLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFalseLiteralExpression()
            dim objectUnderTest = GenerateRedFalseLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNumericLiteralExpression()
            dim objectUnderTest = GenerateRedNumericLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDateLiteralExpression()
            dim objectUnderTest = GenerateRedDateLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedStringLiteralExpression()
            dim objectUnderTest = GenerateRedStringLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNothingLiteralExpression()
            dim objectUnderTest = GenerateRedNothingLiteralExpression()
            Assert.NotNull(objectUnderTest.token)
            Dim withObj = objectUnderTest.WithToken(objectUnderTest.Token)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedParenthesizedExpression()
            dim objectUnderTest = GenerateRedParenthesizedExpression()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithExpression(objectUnderTest.Expression).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTupleExpression()
            dim objectUnderTest = GenerateRedTupleExpression()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.arguments)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithArguments(objectUnderTest.Arguments).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTupleType()
            dim objectUnderTest = GenerateRedTupleType()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.elements)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithElements(objectUnderTest.Elements).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypedTupleElement()
            dim objectUnderTest = GenerateRedTypedTupleElement()
            Assert.NotNull(objectUnderTest.type)
            Dim withObj = objectUnderTest.WithType(objectUnderTest.Type)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNamedTupleElement()
            dim objectUnderTest = GenerateRedNamedTupleElement()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMeExpression()
            dim objectUnderTest = GenerateRedMeExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMyBaseExpression()
            dim objectUnderTest = GenerateRedMyBaseExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMyClassExpression()
            dim objectUnderTest = GenerateRedMyClassExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGetTypeExpression()
            dim objectUnderTest = GenerateRedGetTypeExpression()
            Assert.NotNull(objectUnderTest.getTypeKeyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.type)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithGetTypeKeyword(objectUnderTest.GetTypeKeyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithType(objectUnderTest.Type).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeOfIsExpression()
            dim objectUnderTest = GenerateRedTypeOfIsExpression()
            Assert.NotNull(objectUnderTest.typeOfKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.type)
            Dim withObj = objectUnderTest.WithTypeOfKeyword(objectUnderTest.TypeOfKeyword).WithExpression(objectUnderTest.Expression).WithOperatorToken(objectUnderTest.OperatorToken).WithType(objectUnderTest.Type)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeOfIsNotExpression()
            dim objectUnderTest = GenerateRedTypeOfIsNotExpression()
            Assert.NotNull(objectUnderTest.typeOfKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.type)
            Dim withObj = objectUnderTest.WithTypeOfKeyword(objectUnderTest.TypeOfKeyword).WithExpression(objectUnderTest.Expression).WithOperatorToken(objectUnderTest.OperatorToken).WithType(objectUnderTest.Type)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGetXmlNamespaceExpression()
            dim objectUnderTest = GenerateRedGetXmlNamespaceExpression()
            Assert.NotNull(objectUnderTest.getXmlNamespaceKeyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithGetXmlNamespaceKeyword(objectUnderTest.GetXmlNamespaceKeyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithName(objectUnderTest.Name).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleMemberAccessExpression()
            dim objectUnderTest = GenerateRedSimpleMemberAccessExpression()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithOperatorToken(objectUnderTest.OperatorToken).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDictionaryAccessExpression()
            dim objectUnderTest = GenerateRedDictionaryAccessExpression()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithOperatorToken(objectUnderTest.OperatorToken).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementAccessExpression()
            dim objectUnderTest = GenerateRedXmlElementAccessExpression()
            Assert.NotNull(objectUnderTest.token1)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithBase(objectUnderTest.Base).WithToken1(objectUnderTest.Token1).WithToken2(objectUnderTest.Token2).WithToken3(objectUnderTest.Token3).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDescendantAccessExpression()
            dim objectUnderTest = GenerateRedXmlDescendantAccessExpression()
            Assert.NotNull(objectUnderTest.token1)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithBase(objectUnderTest.Base).WithToken1(objectUnderTest.Token1).WithToken2(objectUnderTest.Token2).WithToken3(objectUnderTest.Token3).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlAttributeAccessExpression()
            dim objectUnderTest = GenerateRedXmlAttributeAccessExpression()
            Assert.NotNull(objectUnderTest.token1)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithBase(objectUnderTest.Base).WithToken1(objectUnderTest.Token1).WithToken2(objectUnderTest.Token2).WithToken3(objectUnderTest.Token3).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInvocationExpression()
            dim objectUnderTest = GenerateRedInvocationExpression()
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithArgumentList(objectUnderTest.ArgumentList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedObjectCreationExpression()
            dim objectUnderTest = GenerateRedObjectCreationExpression()
            Assert.NotNull(objectUnderTest.newKeyword)
            Assert.NotNull(objectUnderTest.type)
            Dim withObj = objectUnderTest.WithNewKeyword(objectUnderTest.NewKeyword).WithAttributeLists(objectUnderTest.AttributeLists).WithType(objectUnderTest.Type).WithArgumentList(objectUnderTest.ArgumentList).WithInitializer(objectUnderTest.Initializer)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAnonymousObjectCreationExpression()
            dim objectUnderTest = GenerateRedAnonymousObjectCreationExpression()
            Assert.NotNull(objectUnderTest.newKeyword)
            Assert.NotNull(objectUnderTest.initializer)
            Dim withObj = objectUnderTest.WithNewKeyword(objectUnderTest.NewKeyword).WithAttributeLists(objectUnderTest.AttributeLists).WithInitializer(objectUnderTest.Initializer)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedArrayCreationExpression()
            dim objectUnderTest = GenerateRedArrayCreationExpression()
            Assert.NotNull(objectUnderTest.newKeyword)
            Assert.NotNull(objectUnderTest.type)
            Assert.NotNull(objectUnderTest.initializer)
            Dim withObj = objectUnderTest.WithNewKeyword(objectUnderTest.NewKeyword).WithAttributeLists(objectUnderTest.AttributeLists).WithType(objectUnderTest.Type).WithArrayBounds(objectUnderTest.ArrayBounds).WithRankSpecifiers(objectUnderTest.RankSpecifiers).WithInitializer(objectUnderTest.Initializer)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCollectionInitializer()
            dim objectUnderTest = GenerateRedCollectionInitializer()
            Assert.NotNull(objectUnderTest.openBraceToken)
            Assert.NotNull(objectUnderTest.closeBraceToken)
            Dim withObj = objectUnderTest.WithOpenBraceToken(objectUnderTest.OpenBraceToken).WithInitializers(objectUnderTest.Initializers).WithCloseBraceToken(objectUnderTest.CloseBraceToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCTypeExpression()
            dim objectUnderTest = GenerateRedCTypeExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.type)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithExpression(objectUnderTest.Expression).WithCommaToken(objectUnderTest.CommaToken).WithType(objectUnderTest.Type).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDirectCastExpression()
            dim objectUnderTest = GenerateRedDirectCastExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.type)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithExpression(objectUnderTest.Expression).WithCommaToken(objectUnderTest.CommaToken).WithType(objectUnderTest.Type).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTryCastExpression()
            dim objectUnderTest = GenerateRedTryCastExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.type)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithExpression(objectUnderTest.Expression).WithCommaToken(objectUnderTest.CommaToken).WithType(objectUnderTest.Type).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedPredefinedCastExpression()
            dim objectUnderTest = GenerateRedPredefinedCastExpression()
            Assert.NotNull(objectUnderTest.keyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithExpression(objectUnderTest.Expression).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAddExpression()
            dim objectUnderTest = GenerateRedAddExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSubtractExpression()
            dim objectUnderTest = GenerateRedSubtractExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiplyExpression()
            dim objectUnderTest = GenerateRedMultiplyExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDivideExpression()
            dim objectUnderTest = GenerateRedDivideExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIntegerDivideExpression()
            dim objectUnderTest = GenerateRedIntegerDivideExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExponentiateExpression()
            dim objectUnderTest = GenerateRedExponentiateExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLeftShiftExpression()
            dim objectUnderTest = GenerateRedLeftShiftExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRightShiftExpression()
            dim objectUnderTest = GenerateRedRightShiftExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedConcatenateExpression()
            dim objectUnderTest = GenerateRedConcatenateExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedModuloExpression()
            dim objectUnderTest = GenerateRedModuloExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEqualsExpression()
            dim objectUnderTest = GenerateRedEqualsExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNotEqualsExpression()
            dim objectUnderTest = GenerateRedNotEqualsExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLessThanExpression()
            dim objectUnderTest = GenerateRedLessThanExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLessThanOrEqualExpression()
            dim objectUnderTest = GenerateRedLessThanOrEqualExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGreaterThanOrEqualExpression()
            dim objectUnderTest = GenerateRedGreaterThanOrEqualExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGreaterThanExpression()
            dim objectUnderTest = GenerateRedGreaterThanExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIsExpression()
            dim objectUnderTest = GenerateRedIsExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIsNotExpression()
            dim objectUnderTest = GenerateRedIsNotExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLikeExpression()
            dim objectUnderTest = GenerateRedLikeExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOrExpression()
            dim objectUnderTest = GenerateRedOrExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExclusiveOrExpression()
            dim objectUnderTest = GenerateRedExclusiveOrExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAndExpression()
            dim objectUnderTest = GenerateRedAndExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOrElseExpression()
            dim objectUnderTest = GenerateRedOrElseExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAndAlsoExpression()
            dim objectUnderTest = GenerateRedAndAlsoExpression()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithOperatorToken(objectUnderTest.OperatorToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedUnaryPlusExpression()
            dim objectUnderTest = GenerateRedUnaryPlusExpression()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.operand)
            Dim withObj = objectUnderTest.WithOperatorToken(objectUnderTest.OperatorToken).WithOperand(objectUnderTest.Operand)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedUnaryMinusExpression()
            dim objectUnderTest = GenerateRedUnaryMinusExpression()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.operand)
            Dim withObj = objectUnderTest.WithOperatorToken(objectUnderTest.OperatorToken).WithOperand(objectUnderTest.Operand)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNotExpression()
            dim objectUnderTest = GenerateRedNotExpression()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.operand)
            Dim withObj = objectUnderTest.WithOperatorToken(objectUnderTest.OperatorToken).WithOperand(objectUnderTest.Operand)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAddressOfExpression()
            dim objectUnderTest = GenerateRedAddressOfExpression()
            Assert.NotNull(objectUnderTest.operatorToken)
            Assert.NotNull(objectUnderTest.operand)
            Dim withObj = objectUnderTest.WithOperatorToken(objectUnderTest.OperatorToken).WithOperand(objectUnderTest.Operand)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedBinaryConditionalExpression()
            dim objectUnderTest = GenerateRedBinaryConditionalExpression()
            Assert.NotNull(objectUnderTest.ifKeyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.firstExpression)
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.secondExpression)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithIfKeyword(objectUnderTest.IfKeyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithFirstExpression(objectUnderTest.FirstExpression).WithCommaToken(objectUnderTest.CommaToken).WithSecondExpression(objectUnderTest.SecondExpression).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTernaryConditionalExpression()
            dim objectUnderTest = GenerateRedTernaryConditionalExpression()
            Assert.NotNull(objectUnderTest.ifKeyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.condition)
            Assert.NotNull(objectUnderTest.firstCommaToken)
            Assert.NotNull(objectUnderTest.whenTrue)
            Assert.NotNull(objectUnderTest.secondCommaToken)
            Assert.NotNull(objectUnderTest.whenFalse)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithIfKeyword(objectUnderTest.IfKeyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithCondition(objectUnderTest.Condition).WithFirstCommaToken(objectUnderTest.FirstCommaToken).WithWhenTrue(objectUnderTest.WhenTrue).WithSecondCommaToken(objectUnderTest.SecondCommaToken).WithWhenFalse(objectUnderTest.WhenFalse).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineFunctionLambdaExpression()
            dim objectUnderTest = GenerateRedSingleLineFunctionLambdaExpression()
            Assert.NotNull(objectUnderTest.subOrFunctionHeader)
            Assert.NotNull(objectUnderTest.body)
            Dim withObj = objectUnderTest.WithSubOrFunctionHeader(objectUnderTest.SubOrFunctionHeader).WithBody(objectUnderTest.Body)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineSubLambdaExpression()
            dim objectUnderTest = GenerateRedSingleLineSubLambdaExpression()
            Assert.NotNull(objectUnderTest.subOrFunctionHeader)
            Assert.NotNull(objectUnderTest.body)
            Dim withObj = objectUnderTest.WithSubOrFunctionHeader(objectUnderTest.SubOrFunctionHeader).WithBody(objectUnderTest.Body)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiLineFunctionLambdaExpression()
            dim objectUnderTest = GenerateRedMultiLineFunctionLambdaExpression()
            Assert.NotNull(objectUnderTest.subOrFunctionHeader)
            Assert.NotNull(objectUnderTest.endSubOrFunctionStatement)
            Dim withObj = objectUnderTest.WithSubOrFunctionHeader(objectUnderTest.SubOrFunctionHeader).WithStatements(objectUnderTest.Statements).WithEndSubOrFunctionStatement(objectUnderTest.EndSubOrFunctionStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiLineSubLambdaExpression()
            dim objectUnderTest = GenerateRedMultiLineSubLambdaExpression()
            Assert.NotNull(objectUnderTest.subOrFunctionHeader)
            Assert.NotNull(objectUnderTest.endSubOrFunctionStatement)
            Dim withObj = objectUnderTest.WithSubOrFunctionHeader(objectUnderTest.SubOrFunctionHeader).WithStatements(objectUnderTest.Statements).WithEndSubOrFunctionStatement(objectUnderTest.EndSubOrFunctionStatement)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSubLambdaHeader()
            dim objectUnderTest = GenerateRedSubLambdaHeader()
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionLambdaHeader()
            dim objectUnderTest = GenerateRedFunctionLambdaHeader()
            Assert.NotNull(objectUnderTest.subOrFunctionKeyword)
            Dim withObj = objectUnderTest.WithAttributeLists(objectUnderTest.AttributeLists).WithModifiers(objectUnderTest.Modifiers).WithSubOrFunctionKeyword(objectUnderTest.SubOrFunctionKeyword).WithParameterList(objectUnderTest.ParameterList).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedArgumentList()
            dim objectUnderTest = GenerateRedArgumentList()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithArguments(objectUnderTest.Arguments).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOmittedArgument()
            dim objectUnderTest = GenerateRedOmittedArgument()
            Assert.NotNull(objectUnderTest.empty)
            Dim withObj = objectUnderTest.WithEmpty(objectUnderTest.Empty)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleArgument()
            dim objectUnderTest = GenerateRedSimpleArgument()
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithNameColonEquals(objectUnderTest.NameColonEquals).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNameColonEquals()
            dim objectUnderTest = GenerateRedNameColonEquals()
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.colonEqualsToken)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithColonEqualsToken(objectUnderTest.ColonEqualsToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRangeArgument()
            dim objectUnderTest = GenerateRedRangeArgument()
            Assert.NotNull(objectUnderTest.lowerBound)
            Assert.NotNull(objectUnderTest.toKeyword)
            Assert.NotNull(objectUnderTest.upperBound)
            Dim withObj = objectUnderTest.WithLowerBound(objectUnderTest.LowerBound).WithToKeyword(objectUnderTest.ToKeyword).WithUpperBound(objectUnderTest.UpperBound)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedQueryExpression()
            dim objectUnderTest = GenerateRedQueryExpression()
            Assert.NotNull(objectUnderTest.clauses)
            Dim withObj = objectUnderTest.WithClauses(objectUnderTest.Clauses)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCollectionRangeVariable()
            dim objectUnderTest = GenerateRedCollectionRangeVariable()
            Assert.NotNull(objectUnderTest.identifier)
            Assert.NotNull(objectUnderTest.inKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier).WithAsClause(objectUnderTest.AsClause).WithInKeyword(objectUnderTest.InKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExpressionRangeVariable()
            dim objectUnderTest = GenerateRedExpressionRangeVariable()
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithNameEquals(objectUnderTest.NameEquals).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAggregationRangeVariable()
            dim objectUnderTest = GenerateRedAggregationRangeVariable()
            Assert.NotNull(objectUnderTest.aggregation)
            Dim withObj = objectUnderTest.WithNameEquals(objectUnderTest.NameEquals).WithAggregation(objectUnderTest.Aggregation)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedVariableNameEquals()
            dim objectUnderTest = GenerateRedVariableNameEquals()
            Assert.NotNull(objectUnderTest.identifier)
            Assert.NotNull(objectUnderTest.equalsToken)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier).WithAsClause(objectUnderTest.AsClause).WithEqualsToken(objectUnderTest.EqualsToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionAggregation()
            dim objectUnderTest = GenerateRedFunctionAggregation()
            Assert.NotNull(objectUnderTest.functionName)
            Dim withObj = objectUnderTest.WithFunctionName(objectUnderTest.FunctionName).WithOpenParenToken(objectUnderTest.OpenParenToken).WithArgument(objectUnderTest.Argument).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGroupAggregation()
            dim objectUnderTest = GenerateRedGroupAggregation()
            Assert.NotNull(objectUnderTest.groupKeyword)
            Dim withObj = objectUnderTest.WithGroupKeyword(objectUnderTest.GroupKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedFromClause()
            dim objectUnderTest = GenerateRedFromClause()
            Assert.NotNull(objectUnderTest.fromKeyword)
            Assert.NotNull(objectUnderTest.variables)
            Dim withObj = objectUnderTest.WithFromKeyword(objectUnderTest.FromKeyword).WithVariables(objectUnderTest.Variables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedLetClause()
            dim objectUnderTest = GenerateRedLetClause()
            Assert.NotNull(objectUnderTest.letKeyword)
            Assert.NotNull(objectUnderTest.variables)
            Dim withObj = objectUnderTest.WithLetKeyword(objectUnderTest.LetKeyword).WithVariables(objectUnderTest.Variables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAggregateClause()
            dim objectUnderTest = GenerateRedAggregateClause()
            Assert.NotNull(objectUnderTest.aggregateKeyword)
            Assert.NotNull(objectUnderTest.variables)
            Assert.NotNull(objectUnderTest.intoKeyword)
            Assert.NotNull(objectUnderTest.aggregationVariables)
            Dim withObj = objectUnderTest.WithAggregateKeyword(objectUnderTest.AggregateKeyword).WithVariables(objectUnderTest.Variables).WithAdditionalQueryOperators(objectUnderTest.AdditionalQueryOperators).WithIntoKeyword(objectUnderTest.IntoKeyword).WithAggregationVariables(objectUnderTest.AggregationVariables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDistinctClause()
            dim objectUnderTest = GenerateRedDistinctClause()
            Assert.NotNull(objectUnderTest.distinctKeyword)
            Dim withObj = objectUnderTest.WithDistinctKeyword(objectUnderTest.DistinctKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWhereClause()
            dim objectUnderTest = GenerateRedWhereClause()
            Assert.NotNull(objectUnderTest.whereKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithWhereKeyword(objectUnderTest.WhereKeyword).WithCondition(objectUnderTest.Condition)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSkipWhileClause()
            dim objectUnderTest = GenerateRedSkipWhileClause()
            Assert.NotNull(objectUnderTest.skipOrTakeKeyword)
            Assert.NotNull(objectUnderTest.whileKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithSkipOrTakeKeyword(objectUnderTest.SkipOrTakeKeyword).WithWhileKeyword(objectUnderTest.WhileKeyword).WithCondition(objectUnderTest.Condition)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTakeWhileClause()
            dim objectUnderTest = GenerateRedTakeWhileClause()
            Assert.NotNull(objectUnderTest.skipOrTakeKeyword)
            Assert.NotNull(objectUnderTest.whileKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithSkipOrTakeKeyword(objectUnderTest.SkipOrTakeKeyword).WithWhileKeyword(objectUnderTest.WhileKeyword).WithCondition(objectUnderTest.Condition)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSkipClause()
            dim objectUnderTest = GenerateRedSkipClause()
            Assert.NotNull(objectUnderTest.skipOrTakeKeyword)
            Assert.NotNull(objectUnderTest.count)
            Dim withObj = objectUnderTest.WithSkipOrTakeKeyword(objectUnderTest.SkipOrTakeKeyword).WithCount(objectUnderTest.Count)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTakeClause()
            dim objectUnderTest = GenerateRedTakeClause()
            Assert.NotNull(objectUnderTest.skipOrTakeKeyword)
            Assert.NotNull(objectUnderTest.count)
            Dim withObj = objectUnderTest.WithSkipOrTakeKeyword(objectUnderTest.SkipOrTakeKeyword).WithCount(objectUnderTest.Count)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGroupByClause()
            dim objectUnderTest = GenerateRedGroupByClause()
            Assert.NotNull(objectUnderTest.groupKeyword)
            Assert.NotNull(objectUnderTest.byKeyword)
            Assert.NotNull(objectUnderTest.keys)
            Assert.NotNull(objectUnderTest.intoKeyword)
            Assert.NotNull(objectUnderTest.aggregationVariables)
            Dim withObj = objectUnderTest.WithGroupKeyword(objectUnderTest.GroupKeyword).WithItems(objectUnderTest.Items).WithByKeyword(objectUnderTest.ByKeyword).WithKeys(objectUnderTest.Keys).WithIntoKeyword(objectUnderTest.IntoKeyword).WithAggregationVariables(objectUnderTest.AggregationVariables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedJoinCondition()
            dim objectUnderTest = GenerateRedJoinCondition()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.equalsKeyword)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithEqualsKeyword(objectUnderTest.EqualsKeyword).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleJoinClause()
            dim objectUnderTest = GenerateRedSimpleJoinClause()
            Assert.NotNull(objectUnderTest.joinKeyword)
            Assert.NotNull(objectUnderTest.joinedVariables)
            Assert.NotNull(objectUnderTest.onKeyword)
            Assert.NotNull(objectUnderTest.joinConditions)
            Dim withObj = objectUnderTest.WithJoinKeyword(objectUnderTest.JoinKeyword).WithJoinedVariables(objectUnderTest.JoinedVariables).WithAdditionalJoins(objectUnderTest.AdditionalJoins).WithOnKeyword(objectUnderTest.OnKeyword).WithJoinConditions(objectUnderTest.JoinConditions)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGroupJoinClause()
            dim objectUnderTest = GenerateRedGroupJoinClause()
            Assert.NotNull(objectUnderTest.groupKeyword)
            Assert.NotNull(objectUnderTest.joinKeyword)
            Assert.NotNull(objectUnderTest.joinedVariables)
            Assert.NotNull(objectUnderTest.onKeyword)
            Assert.NotNull(objectUnderTest.joinConditions)
            Assert.NotNull(objectUnderTest.intoKeyword)
            Assert.NotNull(objectUnderTest.aggregationVariables)
            Dim withObj = objectUnderTest.WithGroupKeyword(objectUnderTest.GroupKeyword).WithJoinKeyword(objectUnderTest.JoinKeyword).WithJoinedVariables(objectUnderTest.JoinedVariables).WithAdditionalJoins(objectUnderTest.AdditionalJoins).WithOnKeyword(objectUnderTest.OnKeyword).WithJoinConditions(objectUnderTest.JoinConditions).WithIntoKeyword(objectUnderTest.IntoKeyword).WithAggregationVariables(objectUnderTest.AggregationVariables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedOrderByClause()
            dim objectUnderTest = GenerateRedOrderByClause()
            Assert.NotNull(objectUnderTest.orderKeyword)
            Assert.NotNull(objectUnderTest.byKeyword)
            Assert.NotNull(objectUnderTest.orderings)
            Dim withObj = objectUnderTest.WithOrderKeyword(objectUnderTest.OrderKeyword).WithByKeyword(objectUnderTest.ByKeyword).WithOrderings(objectUnderTest.Orderings)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAscendingOrdering()
            dim objectUnderTest = GenerateRedAscendingOrdering()
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithAscendingOrDescendingKeyword(objectUnderTest.AscendingOrDescendingKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDescendingOrdering()
            dim objectUnderTest = GenerateRedDescendingOrdering()
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithAscendingOrDescendingKeyword(objectUnderTest.AscendingOrDescendingKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedSelectClause()
            dim objectUnderTest = GenerateRedSelectClause()
            Assert.NotNull(objectUnderTest.selectKeyword)
            Assert.NotNull(objectUnderTest.variables)
            Dim withObj = objectUnderTest.WithSelectKeyword(objectUnderTest.SelectKeyword).WithVariables(objectUnderTest.Variables)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDocument()
            dim objectUnderTest = GenerateRedXmlDocument()
            Assert.NotNull(objectUnderTest.declaration)
            Assert.NotNull(objectUnderTest.root)
            Dim withObj = objectUnderTest.WithDeclaration(objectUnderTest.Declaration).WithPrecedingMisc(objectUnderTest.PrecedingMisc).WithRoot(objectUnderTest.Root).WithFollowingMisc(objectUnderTest.FollowingMisc)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDeclaration()
            dim objectUnderTest = GenerateRedXmlDeclaration()
            Assert.NotNull(objectUnderTest.lessThanQuestionToken)
            Assert.NotNull(objectUnderTest.xmlKeyword)
            Assert.NotNull(objectUnderTest.version)
            Assert.NotNull(objectUnderTest.questionGreaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanQuestionToken(objectUnderTest.LessThanQuestionToken).WithXmlKeyword(objectUnderTest.XmlKeyword).WithVersion(objectUnderTest.Version).WithEncoding(objectUnderTest.Encoding).WithStandalone(objectUnderTest.Standalone).WithQuestionGreaterThanToken(objectUnderTest.QuestionGreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDeclarationOption()
            dim objectUnderTest = GenerateRedXmlDeclarationOption()
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.equals)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithEquals(objectUnderTest.Equals).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElement()
            dim objectUnderTest = GenerateRedXmlElement()
            Assert.NotNull(objectUnderTest.startTag)
            Assert.NotNull(objectUnderTest.endTag)
            Dim withObj = objectUnderTest.WithStartTag(objectUnderTest.StartTag).WithContent(objectUnderTest.Content).WithEndTag(objectUnderTest.EndTag)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlText()
            dim objectUnderTest = GenerateRedXmlText()
            Assert.NotNull(objectUnderTest.textTokens)
            Dim withObj = objectUnderTest.WithTextTokens(objectUnderTest.TextTokens)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementStartTag()
            dim objectUnderTest = GenerateRedXmlElementStartTag()
            Assert.NotNull(objectUnderTest.lessThanToken)
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.greaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanToken(objectUnderTest.LessThanToken).WithName(objectUnderTest.Name).WithAttributes(objectUnderTest.Attributes).WithGreaterThanToken(objectUnderTest.GreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementEndTag()
            dim objectUnderTest = GenerateRedXmlElementEndTag()
            Assert.NotNull(objectUnderTest.lessThanSlashToken)
            Assert.NotNull(objectUnderTest.greaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanSlashToken(objectUnderTest.LessThanSlashToken).WithName(objectUnderTest.Name).WithGreaterThanToken(objectUnderTest.GreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlEmptyElement()
            dim objectUnderTest = GenerateRedXmlEmptyElement()
            Assert.NotNull(objectUnderTest.lessThanToken)
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.slashGreaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanToken(objectUnderTest.LessThanToken).WithName(objectUnderTest.Name).WithAttributes(objectUnderTest.Attributes).WithSlashGreaterThanToken(objectUnderTest.SlashGreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlAttribute()
            dim objectUnderTest = GenerateRedXmlAttribute()
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithEqualsToken(objectUnderTest.EqualsToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlString()
            dim objectUnderTest = GenerateRedXmlString()
            Assert.NotNull(objectUnderTest.startQuoteToken)
            Assert.NotNull(objectUnderTest.endQuoteToken)
            Dim withObj = objectUnderTest.WithStartQuoteToken(objectUnderTest.StartQuoteToken).WithTextTokens(objectUnderTest.TextTokens).WithEndQuoteToken(objectUnderTest.EndQuoteToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlPrefixName()
            dim objectUnderTest = GenerateRedXmlPrefixName()
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlName()
            dim objectUnderTest = GenerateRedXmlName()
            Assert.NotNull(objectUnderTest.localName)
            Dim withObj = objectUnderTest.WithPrefix(objectUnderTest.Prefix).WithLocalName(objectUnderTest.LocalName)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlBracketedName()
            dim objectUnderTest = GenerateRedXmlBracketedName()
            Assert.NotNull(objectUnderTest.lessThanToken)
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.greaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanToken(objectUnderTest.LessThanToken).WithName(objectUnderTest.Name).WithGreaterThanToken(objectUnderTest.GreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlPrefix()
            dim objectUnderTest = GenerateRedXmlPrefix()
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.colonToken)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithColonToken(objectUnderTest.ColonToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlComment()
            dim objectUnderTest = GenerateRedXmlComment()
            Assert.NotNull(objectUnderTest.lessThanExclamationMinusMinusToken)
            Assert.NotNull(objectUnderTest.textTokens)
            Assert.NotNull(objectUnderTest.minusMinusGreaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanExclamationMinusMinusToken(objectUnderTest.LessThanExclamationMinusMinusToken).WithTextTokens(objectUnderTest.TextTokens).WithMinusMinusGreaterThanToken(objectUnderTest.MinusMinusGreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlProcessingInstruction()
            dim objectUnderTest = GenerateRedXmlProcessingInstruction()
            Assert.NotNull(objectUnderTest.lessThanQuestionToken)
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.textTokens)
            Assert.NotNull(objectUnderTest.questionGreaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanQuestionToken(objectUnderTest.LessThanQuestionToken).WithName(objectUnderTest.Name).WithTextTokens(objectUnderTest.TextTokens).WithQuestionGreaterThanToken(objectUnderTest.QuestionGreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlCDataSection()
            dim objectUnderTest = GenerateRedXmlCDataSection()
            Assert.NotNull(objectUnderTest.beginCDataToken)
            Assert.NotNull(objectUnderTest.textTokens)
            Assert.NotNull(objectUnderTest.endCDataToken)
            Dim withObj = objectUnderTest.WithBeginCDataToken(objectUnderTest.BeginCDataToken).WithTextTokens(objectUnderTest.TextTokens).WithEndCDataToken(objectUnderTest.EndCDataToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlEmbeddedExpression()
            dim objectUnderTest = GenerateRedXmlEmbeddedExpression()
            Assert.NotNull(objectUnderTest.lessThanPercentEqualsToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.percentGreaterThanToken)
            Dim withObj = objectUnderTest.WithLessThanPercentEqualsToken(objectUnderTest.LessThanPercentEqualsToken).WithExpression(objectUnderTest.Expression).WithPercentGreaterThanToken(objectUnderTest.PercentGreaterThanToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedArrayType()
            dim objectUnderTest = GenerateRedArrayType()
            Assert.NotNull(objectUnderTest.elementType)
            Assert.NotNull(objectUnderTest.rankSpecifiers)
            Dim withObj = objectUnderTest.WithElementType(objectUnderTest.ElementType).WithRankSpecifiers(objectUnderTest.RankSpecifiers)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNullableType()
            dim objectUnderTest = GenerateRedNullableType()
            Assert.NotNull(objectUnderTest.elementType)
            Assert.NotNull(objectUnderTest.questionMarkToken)
            Dim withObj = objectUnderTest.WithElementType(objectUnderTest.ElementType).WithQuestionMarkToken(objectUnderTest.QuestionMarkToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedPredefinedType()
            dim objectUnderTest = GenerateRedPredefinedType()
            Assert.NotNull(objectUnderTest.keyword)
            Dim withObj = objectUnderTest.WithKeyword(objectUnderTest.Keyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIdentifierName()
            dim objectUnderTest = GenerateRedIdentifierName()
            Assert.NotNull(objectUnderTest.identifier)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGenericName()
            dim objectUnderTest = GenerateRedGenericName()
            Assert.NotNull(objectUnderTest.identifier)
            Assert.NotNull(objectUnderTest.typeArgumentList)
            Dim withObj = objectUnderTest.WithIdentifier(objectUnderTest.Identifier).WithTypeArgumentList(objectUnderTest.TypeArgumentList)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedQualifiedName()
            dim objectUnderTest = GenerateRedQualifiedName()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.dotToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithDotToken(objectUnderTest.DotToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedGlobalName()
            dim objectUnderTest = GenerateRedGlobalName()
            Assert.NotNull(objectUnderTest.globalKeyword)
            Dim withObj = objectUnderTest.WithGlobalKeyword(objectUnderTest.GlobalKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeArgumentList()
            dim objectUnderTest = GenerateRedTypeArgumentList()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.ofKeyword)
            Assert.NotNull(objectUnderTest.arguments)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithOfKeyword(objectUnderTest.OfKeyword).WithArguments(objectUnderTest.Arguments).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefReference()
            dim objectUnderTest = GenerateRedCrefReference()
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithSignature(objectUnderTest.Signature).WithAsClause(objectUnderTest.AsClause)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefSignature()
            dim objectUnderTest = GenerateRedCrefSignature()
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.argumentTypes)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithOpenParenToken(objectUnderTest.OpenParenToken).WithArgumentTypes(objectUnderTest.ArgumentTypes).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefSignaturePart()
            dim objectUnderTest = GenerateRedCrefSignaturePart()
            Dim withObj = objectUnderTest.WithModifier(objectUnderTest.Modifier).WithType(objectUnderTest.Type)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefOperatorReference()
            dim objectUnderTest = GenerateRedCrefOperatorReference()
            Assert.NotNull(objectUnderTest.operatorKeyword)
            Assert.NotNull(objectUnderTest.operatorToken)
            Dim withObj = objectUnderTest.WithOperatorKeyword(objectUnderTest.OperatorKeyword).WithOperatorToken(objectUnderTest.OperatorToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedQualifiedCrefOperatorReference()
            dim objectUnderTest = GenerateRedQualifiedCrefOperatorReference()
            Assert.NotNull(objectUnderTest.left)
            Assert.NotNull(objectUnderTest.dotToken)
            Assert.NotNull(objectUnderTest.right)
            Dim withObj = objectUnderTest.WithLeft(objectUnderTest.Left).WithDotToken(objectUnderTest.DotToken).WithRight(objectUnderTest.Right)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedYieldStatement()
            dim objectUnderTest = GenerateRedYieldStatement()
            Assert.NotNull(objectUnderTest.yieldKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithYieldKeyword(objectUnderTest.YieldKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedAwaitExpression()
            dim objectUnderTest = GenerateRedAwaitExpression()
            Assert.NotNull(objectUnderTest.awaitKeyword)
            Assert.NotNull(objectUnderTest.expression)
            Dim withObj = objectUnderTest.WithAwaitKeyword(objectUnderTest.AwaitKeyword).WithExpression(objectUnderTest.Expression)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlNameToken()
            dim objectUnderTest = GenerateRedXmlNameToken()
        End Sub
 
        <Fact>
        Public Sub TestRedXmlTextLiteralToken()
            dim objectUnderTest = GenerateRedXmlTextLiteralToken()
        End Sub
 
        <Fact>
        Public Sub TestRedXmlEntityLiteralToken()
            dim objectUnderTest = GenerateRedXmlEntityLiteralToken()
        End Sub
 
        <Fact>
        Public Sub TestRedDocumentationCommentLineBreakToken()
            dim objectUnderTest = GenerateRedDocumentationCommentLineBreakToken()
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolatedStringTextToken()
            dim objectUnderTest = GenerateRedInterpolatedStringTextToken()
        End Sub
 
        <Fact>
        Public Sub TestRedDecimalLiteralToken()
            dim objectUnderTest = GenerateRedDecimalLiteralToken()
        End Sub
 
        <Fact>
        Public Sub TestRedDateLiteralToken()
            dim objectUnderTest = GenerateRedDateLiteralToken()
        End Sub
 
        <Fact>
        Public Sub TestRedStringLiteralToken()
            dim objectUnderTest = GenerateRedStringLiteralToken()
        End Sub
 
        <Fact>
        Public Sub TestRedCharacterLiteralToken()
            dim objectUnderTest = GenerateRedCharacterLiteralToken()
        End Sub
 
        <Fact>
        Public Sub TestRedSkippedTokensTrivia()
            dim objectUnderTest = GenerateRedSkippedTokensTrivia()
            Dim withObj = objectUnderTest.WithTokens(objectUnderTest.Tokens)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDocumentationCommentTrivia()
            dim objectUnderTest = GenerateRedDocumentationCommentTrivia()
            Dim withObj = objectUnderTest.WithContent(objectUnderTest.Content)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlCrefAttribute()
            dim objectUnderTest = GenerateRedXmlCrefAttribute()
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.startQuoteToken)
            Assert.NotNull(objectUnderTest.reference)
            Assert.NotNull(objectUnderTest.endQuoteToken)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithEqualsToken(objectUnderTest.EqualsToken).WithStartQuoteToken(objectUnderTest.StartQuoteToken).WithReference(objectUnderTest.Reference).WithEndQuoteToken(objectUnderTest.EndQuoteToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlNameAttribute()
            dim objectUnderTest = GenerateRedXmlNameAttribute()
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.startQuoteToken)
            Assert.NotNull(objectUnderTest.reference)
            Assert.NotNull(objectUnderTest.endQuoteToken)
            Dim withObj = objectUnderTest.WithName(objectUnderTest.Name).WithEqualsToken(objectUnderTest.EqualsToken).WithStartQuoteToken(objectUnderTest.StartQuoteToken).WithReference(objectUnderTest.Reference).WithEndQuoteToken(objectUnderTest.EndQuoteToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedConditionalAccessExpression()
            dim objectUnderTest = GenerateRedConditionalAccessExpression()
            Assert.NotNull(objectUnderTest.questionMarkToken)
            Assert.NotNull(objectUnderTest.whenNotNull)
            Dim withObj = objectUnderTest.WithExpression(objectUnderTest.Expression).WithQuestionMarkToken(objectUnderTest.QuestionMarkToken).WithWhenNotNull(objectUnderTest.WhenNotNull)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedNameOfExpression()
            dim objectUnderTest = GenerateRedNameOfExpression()
            Assert.NotNull(objectUnderTest.nameOfKeyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.argument)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithNameOfKeyword(objectUnderTest.NameOfKeyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithArgument(objectUnderTest.Argument).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolatedStringExpression()
            dim objectUnderTest = GenerateRedInterpolatedStringExpression()
            Assert.NotNull(objectUnderTest.dollarSignDoubleQuoteToken)
            Assert.NotNull(objectUnderTest.contents)
            Assert.NotNull(objectUnderTest.doubleQuoteToken)
            Dim withObj = objectUnderTest.WithDollarSignDoubleQuoteToken(objectUnderTest.DollarSignDoubleQuoteToken).WithContents(objectUnderTest.Contents).WithDoubleQuoteToken(objectUnderTest.DoubleQuoteToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolatedStringText()
            dim objectUnderTest = GenerateRedInterpolatedStringText()
            Assert.NotNull(objectUnderTest.textToken)
            Dim withObj = objectUnderTest.WithTextToken(objectUnderTest.TextToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolation()
            dim objectUnderTest = GenerateRedInterpolation()
            Assert.NotNull(objectUnderTest.openBraceToken)
            Assert.NotNull(objectUnderTest.expression)
            Assert.NotNull(objectUnderTest.closeBraceToken)
            Dim withObj = objectUnderTest.WithOpenBraceToken(objectUnderTest.OpenBraceToken).WithExpression(objectUnderTest.Expression).WithAlignmentClause(objectUnderTest.AlignmentClause).WithFormatClause(objectUnderTest.FormatClause).WithCloseBraceToken(objectUnderTest.CloseBraceToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolationAlignmentClause()
            dim objectUnderTest = GenerateRedInterpolationAlignmentClause()
            Assert.NotNull(objectUnderTest.commaToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithCommaToken(objectUnderTest.CommaToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolationFormatClause()
            dim objectUnderTest = GenerateRedInterpolationFormatClause()
            Assert.NotNull(objectUnderTest.colonToken)
            Assert.NotNull(objectUnderTest.formatStringToken)
            Dim withObj = objectUnderTest.WithColonToken(objectUnderTest.ColonToken).WithFormatStringToken(objectUnderTest.FormatStringToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedWhitespaceTrivia()
            dim objectUnderTest = GenerateRedWhitespaceTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedEndOfLineTrivia()
            dim objectUnderTest = GenerateRedEndOfLineTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedColonTrivia()
            dim objectUnderTest = GenerateRedColonTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedCommentTrivia()
            dim objectUnderTest = GenerateRedCommentTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedConflictMarkerTrivia()
            dim objectUnderTest = GenerateRedConflictMarkerTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedLineContinuationTrivia()
            dim objectUnderTest = GenerateRedLineContinuationTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedDocumentationCommentExteriorTrivia()
            dim objectUnderTest = GenerateRedDocumentationCommentExteriorTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedDisabledTextTrivia()
            dim objectUnderTest = GenerateRedDisabledTextTrivia()
        End Sub
 
        <Fact>
        Public Sub TestRedConstDirectiveTrivia()
            dim objectUnderTest = GenerateRedConstDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.constKeyword)
            Assert.NotNull(objectUnderTest.name)
            Assert.NotNull(objectUnderTest.equalsToken)
            Assert.NotNull(objectUnderTest.value)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithConstKeyword(objectUnderTest.ConstKeyword).WithName(objectUnderTest.Name).WithEqualsToken(objectUnderTest.EqualsToken).WithValue(objectUnderTest.Value)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedIfDirectiveTrivia()
            dim objectUnderTest = GenerateRedIfDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.ifOrElseIfKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithElseKeyword(objectUnderTest.ElseKeyword).WithIfOrElseIfKeyword(objectUnderTest.IfOrElseIfKeyword).WithCondition(objectUnderTest.Condition).WithThenKeyword(objectUnderTest.ThenKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseIfDirectiveTrivia()
            dim objectUnderTest = GenerateRedElseIfDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.ifOrElseIfKeyword)
            Assert.NotNull(objectUnderTest.condition)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithElseKeyword(objectUnderTest.ElseKeyword).WithIfOrElseIfKeyword(objectUnderTest.IfOrElseIfKeyword).WithCondition(objectUnderTest.Condition).WithThenKeyword(objectUnderTest.ThenKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedElseDirectiveTrivia()
            dim objectUnderTest = GenerateRedElseDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.elseKeyword)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithElseKeyword(objectUnderTest.ElseKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndIfDirectiveTrivia()
            dim objectUnderTest = GenerateRedEndIfDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.ifKeyword)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithEndKeyword(objectUnderTest.EndKeyword).WithIfKeyword(objectUnderTest.IfKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedRegionDirectiveTrivia()
            dim objectUnderTest = GenerateRedRegionDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.regionKeyword)
            Assert.NotNull(objectUnderTest.name)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithRegionKeyword(objectUnderTest.RegionKeyword).WithName(objectUnderTest.Name)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEndRegionDirectiveTrivia()
            dim objectUnderTest = GenerateRedEndRegionDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.endKeyword)
            Assert.NotNull(objectUnderTest.regionKeyword)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithEndKeyword(objectUnderTest.EndKeyword).WithRegionKeyword(objectUnderTest.RegionKeyword)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedExternalChecksumDirectiveTrivia()
            dim objectUnderTest = GenerateRedExternalChecksumDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.externalChecksumKeyword)
            Assert.NotNull(objectUnderTest.openParenToken)
            Assert.NotNull(objectUnderTest.externalSource)
            Assert.NotNull(objectUnderTest.firstCommaToken)
            Assert.NotNull(objectUnderTest.guid)
            Assert.NotNull(objectUnderTest.secondCommaToken)
            Assert.NotNull(objectUnderTest.checksum)
            Assert.NotNull(objectUnderTest.closeParenToken)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithExternalChecksumKeyword(objectUnderTest.ExternalChecksumKeyword).WithOpenParenToken(objectUnderTest.OpenParenToken).WithExternalSource(objectUnderTest.ExternalSource).WithFirstCommaToken(objectUnderTest.FirstCommaToken).WithGuid(objectUnderTest.Guid).WithSecondCommaToken(objectUnderTest.SecondCommaToken).WithChecksum(objectUnderTest.Checksum).WithCloseParenToken(objectUnderTest.CloseParenToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedEnableWarningDirectiveTrivia()
            dim objectUnderTest = GenerateRedEnableWarningDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.enableKeyword)
            Assert.NotNull(objectUnderTest.warningKeyword)
            Assert.NotNull(objectUnderTest.errorCodes)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithEnableKeyword(objectUnderTest.EnableKeyword).WithWarningKeyword(objectUnderTest.WarningKeyword).WithErrorCodes(objectUnderTest.ErrorCodes)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedDisableWarningDirectiveTrivia()
            dim objectUnderTest = GenerateRedDisableWarningDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.disableKeyword)
            Assert.NotNull(objectUnderTest.warningKeyword)
            Assert.NotNull(objectUnderTest.errorCodes)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithDisableKeyword(objectUnderTest.DisableKeyword).WithWarningKeyword(objectUnderTest.WarningKeyword).WithErrorCodes(objectUnderTest.ErrorCodes)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedReferenceDirectiveTrivia()
            dim objectUnderTest = GenerateRedReferenceDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Assert.NotNull(objectUnderTest.referenceKeyword)
            Assert.NotNull(objectUnderTest.file)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken).WithReferenceKeyword(objectUnderTest.ReferenceKeyword).WithFile(objectUnderTest.File)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
        <Fact>
        Public Sub TestRedBadDirectiveTrivia()
            dim objectUnderTest = GenerateRedBadDirectiveTrivia()
            Assert.NotNull(objectUnderTest.hashToken)
            Dim withObj = objectUnderTest.WithHashToken(objectUnderTest.HashToken)
            Assert.Equal(withobj, objectUnderTest)
        End Sub
 
#end region
 
#region "Red Rewriter Tests"
        <Fact>
        Public Sub TestRedEmptyStatementRewriter()
            dim oldNode = GenerateRedEmptyStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndIfStatementRewriter()
            dim oldNode = GenerateRedEndIfStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndUsingStatementRewriter()
            dim oldNode = GenerateRedEndUsingStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndWithStatementRewriter()
            dim oldNode = GenerateRedEndWithStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSelectStatementRewriter()
            dim oldNode = GenerateRedEndSelectStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndStructureStatementRewriter()
            dim oldNode = GenerateRedEndStructureStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndEnumStatementRewriter()
            dim oldNode = GenerateRedEndEnumStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndInterfaceStatementRewriter()
            dim oldNode = GenerateRedEndInterfaceStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndClassStatementRewriter()
            dim oldNode = GenerateRedEndClassStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndModuleStatementRewriter()
            dim oldNode = GenerateRedEndModuleStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndNamespaceStatementRewriter()
            dim oldNode = GenerateRedEndNamespaceStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSubStatementRewriter()
            dim oldNode = GenerateRedEndSubStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndFunctionStatementRewriter()
            dim oldNode = GenerateRedEndFunctionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndGetStatementRewriter()
            dim oldNode = GenerateRedEndGetStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSetStatementRewriter()
            dim oldNode = GenerateRedEndSetStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndPropertyStatementRewriter()
            dim oldNode = GenerateRedEndPropertyStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndOperatorStatementRewriter()
            dim oldNode = GenerateRedEndOperatorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndEventStatementRewriter()
            dim oldNode = GenerateRedEndEventStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndAddHandlerStatementRewriter()
            dim oldNode = GenerateRedEndAddHandlerStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndRemoveHandlerStatementRewriter()
            dim oldNode = GenerateRedEndRemoveHandlerStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndRaiseEventStatementRewriter()
            dim oldNode = GenerateRedEndRaiseEventStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndWhileStatementRewriter()
            dim oldNode = GenerateRedEndWhileStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndTryStatementRewriter()
            dim oldNode = GenerateRedEndTryStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndSyncLockStatementRewriter()
            dim oldNode = GenerateRedEndSyncLockStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCompilationUnitRewriter()
            dim oldNode = GenerateRedCompilationUnit()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOptionStatementRewriter()
            dim oldNode = GenerateRedOptionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedImportsStatementRewriter()
            dim oldNode = GenerateRedImportsStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleImportsClauseRewriter()
            dim oldNode = GenerateRedSimpleImportsClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedImportAliasClauseRewriter()
            dim oldNode = GenerateRedImportAliasClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlNamespaceImportsClauseRewriter()
            dim oldNode = GenerateRedXmlNamespaceImportsClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNamespaceBlockRewriter()
            dim oldNode = GenerateRedNamespaceBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNamespaceStatementRewriter()
            dim oldNode = GenerateRedNamespaceStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedModuleBlockRewriter()
            dim oldNode = GenerateRedModuleBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedStructureBlockRewriter()
            dim oldNode = GenerateRedStructureBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterfaceBlockRewriter()
            dim oldNode = GenerateRedInterfaceBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedClassBlockRewriter()
            dim oldNode = GenerateRedClassBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEnumBlockRewriter()
            dim oldNode = GenerateRedEnumBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInheritsStatementRewriter()
            dim oldNode = GenerateRedInheritsStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedImplementsStatementRewriter()
            dim oldNode = GenerateRedImplementsStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedModuleStatementRewriter()
            dim oldNode = GenerateRedModuleStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedStructureStatementRewriter()
            dim oldNode = GenerateRedStructureStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterfaceStatementRewriter()
            dim oldNode = GenerateRedInterfaceStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedClassStatementRewriter()
            dim oldNode = GenerateRedClassStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEnumStatementRewriter()
            dim oldNode = GenerateRedEnumStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterListRewriter()
            dim oldNode = GenerateRedTypeParameterList()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterRewriter()
            dim oldNode = GenerateRedTypeParameter()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterSingleConstraintClauseRewriter()
            dim oldNode = GenerateRedTypeParameterSingleConstraintClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeParameterMultipleConstraintClauseRewriter()
            dim oldNode = GenerateRedTypeParameterMultipleConstraintClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNewConstraintRewriter()
            dim oldNode = GenerateRedNewConstraint()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedClassConstraintRewriter()
            dim oldNode = GenerateRedClassConstraint()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedStructureConstraintRewriter()
            dim oldNode = GenerateRedStructureConstraint()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeConstraintRewriter()
            dim oldNode = GenerateRedTypeConstraint()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEnumMemberDeclarationRewriter()
            dim oldNode = GenerateRedEnumMemberDeclaration()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSubBlockRewriter()
            dim oldNode = GenerateRedSubBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionBlockRewriter()
            dim oldNode = GenerateRedFunctionBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedConstructorBlockRewriter()
            dim oldNode = GenerateRedConstructorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOperatorBlockRewriter()
            dim oldNode = GenerateRedOperatorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGetAccessorBlockRewriter()
            dim oldNode = GenerateRedGetAccessorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSetAccessorBlockRewriter()
            dim oldNode = GenerateRedSetAccessorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAddHandlerAccessorBlockRewriter()
            dim oldNode = GenerateRedAddHandlerAccessorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRemoveHandlerAccessorBlockRewriter()
            dim oldNode = GenerateRedRemoveHandlerAccessorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRaiseEventAccessorBlockRewriter()
            dim oldNode = GenerateRedRaiseEventAccessorBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedPropertyBlockRewriter()
            dim oldNode = GenerateRedPropertyBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEventBlockRewriter()
            dim oldNode = GenerateRedEventBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedParameterListRewriter()
            dim oldNode = GenerateRedParameterList()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSubStatementRewriter()
            dim oldNode = GenerateRedSubStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionStatementRewriter()
            dim oldNode = GenerateRedFunctionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSubNewStatementRewriter()
            dim oldNode = GenerateRedSubNewStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDeclareSubStatementRewriter()
            dim oldNode = GenerateRedDeclareSubStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDeclareFunctionStatementRewriter()
            dim oldNode = GenerateRedDeclareFunctionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDelegateSubStatementRewriter()
            dim oldNode = GenerateRedDelegateSubStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDelegateFunctionStatementRewriter()
            dim oldNode = GenerateRedDelegateFunctionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEventStatementRewriter()
            dim oldNode = GenerateRedEventStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOperatorStatementRewriter()
            dim oldNode = GenerateRedOperatorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedPropertyStatementRewriter()
            dim oldNode = GenerateRedPropertyStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGetAccessorStatementRewriter()
            dim oldNode = GenerateRedGetAccessorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSetAccessorStatementRewriter()
            dim oldNode = GenerateRedSetAccessorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAddHandlerAccessorStatementRewriter()
            dim oldNode = GenerateRedAddHandlerAccessorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRemoveHandlerAccessorStatementRewriter()
            dim oldNode = GenerateRedRemoveHandlerAccessorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRaiseEventAccessorStatementRewriter()
            dim oldNode = GenerateRedRaiseEventAccessorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedImplementsClauseRewriter()
            dim oldNode = GenerateRedImplementsClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedHandlesClauseRewriter()
            dim oldNode = GenerateRedHandlesClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedKeywordEventContainerRewriter()
            dim oldNode = GenerateRedKeywordEventContainer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWithEventsEventContainerRewriter()
            dim oldNode = GenerateRedWithEventsEventContainer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWithEventsPropertyEventContainerRewriter()
            dim oldNode = GenerateRedWithEventsPropertyEventContainer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedHandlesClauseItemRewriter()
            dim oldNode = GenerateRedHandlesClauseItem()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIncompleteMemberRewriter()
            dim oldNode = GenerateRedIncompleteMember()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFieldDeclarationRewriter()
            dim oldNode = GenerateRedFieldDeclaration()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedVariableDeclaratorRewriter()
            dim oldNode = GenerateRedVariableDeclarator()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleAsClauseRewriter()
            dim oldNode = GenerateRedSimpleAsClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAsNewClauseRewriter()
            dim oldNode = GenerateRedAsNewClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedObjectMemberInitializerRewriter()
            dim oldNode = GenerateRedObjectMemberInitializer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedObjectCollectionInitializerRewriter()
            dim oldNode = GenerateRedObjectCollectionInitializer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInferredFieldInitializerRewriter()
            dim oldNode = GenerateRedInferredFieldInitializer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNamedFieldInitializerRewriter()
            dim oldNode = GenerateRedNamedFieldInitializer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEqualsValueRewriter()
            dim oldNode = GenerateRedEqualsValue()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedParameterRewriter()
            dim oldNode = GenerateRedParameter()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedModifiedIdentifierRewriter()
            dim oldNode = GenerateRedModifiedIdentifier()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedArrayRankSpecifierRewriter()
            dim oldNode = GenerateRedArrayRankSpecifier()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributeListRewriter()
            dim oldNode = GenerateRedAttributeList()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributeRewriter()
            dim oldNode = GenerateRedAttribute()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributeTargetRewriter()
            dim oldNode = GenerateRedAttributeTarget()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAttributesStatementRewriter()
            dim oldNode = GenerateRedAttributesStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExpressionStatementRewriter()
            dim oldNode = GenerateRedExpressionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedPrintStatementRewriter()
            dim oldNode = GenerateRedPrintStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWhileBlockRewriter()
            dim oldNode = GenerateRedWhileBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedUsingBlockRewriter()
            dim oldNode = GenerateRedUsingBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSyncLockBlockRewriter()
            dim oldNode = GenerateRedSyncLockBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWithBlockRewriter()
            dim oldNode = GenerateRedWithBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLocalDeclarationStatementRewriter()
            dim oldNode = GenerateRedLocalDeclarationStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLabelStatementRewriter()
            dim oldNode = GenerateRedLabelStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGoToStatementRewriter()
            dim oldNode = GenerateRedGoToStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIdentifierLabelRewriter()
            dim oldNode = GenerateRedIdentifierLabel()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNumericLabelRewriter()
            dim oldNode = GenerateRedNumericLabel()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNextLabelRewriter()
            dim oldNode = GenerateRedNextLabel()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedStopStatementRewriter()
            dim oldNode = GenerateRedStopStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndStatementRewriter()
            dim oldNode = GenerateRedEndStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitDoStatementRewriter()
            dim oldNode = GenerateRedExitDoStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitForStatementRewriter()
            dim oldNode = GenerateRedExitForStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitSubStatementRewriter()
            dim oldNode = GenerateRedExitSubStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitFunctionStatementRewriter()
            dim oldNode = GenerateRedExitFunctionStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitOperatorStatementRewriter()
            dim oldNode = GenerateRedExitOperatorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitPropertyStatementRewriter()
            dim oldNode = GenerateRedExitPropertyStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitTryStatementRewriter()
            dim oldNode = GenerateRedExitTryStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitSelectStatementRewriter()
            dim oldNode = GenerateRedExitSelectStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExitWhileStatementRewriter()
            dim oldNode = GenerateRedExitWhileStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedContinueWhileStatementRewriter()
            dim oldNode = GenerateRedContinueWhileStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedContinueDoStatementRewriter()
            dim oldNode = GenerateRedContinueDoStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedContinueForStatementRewriter()
            dim oldNode = GenerateRedContinueForStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedReturnStatementRewriter()
            dim oldNode = GenerateRedReturnStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineIfStatementRewriter()
            dim oldNode = GenerateRedSingleLineIfStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineElseClauseRewriter()
            dim oldNode = GenerateRedSingleLineElseClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiLineIfBlockRewriter()
            dim oldNode = GenerateRedMultiLineIfBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIfStatementRewriter()
            dim oldNode = GenerateRedIfStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseIfBlockRewriter()
            dim oldNode = GenerateRedElseIfBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseIfStatementRewriter()
            dim oldNode = GenerateRedElseIfStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseBlockRewriter()
            dim oldNode = GenerateRedElseBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseStatementRewriter()
            dim oldNode = GenerateRedElseStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTryBlockRewriter()
            dim oldNode = GenerateRedTryBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTryStatementRewriter()
            dim oldNode = GenerateRedTryStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCatchBlockRewriter()
            dim oldNode = GenerateRedCatchBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCatchStatementRewriter()
            dim oldNode = GenerateRedCatchStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCatchFilterClauseRewriter()
            dim oldNode = GenerateRedCatchFilterClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFinallyBlockRewriter()
            dim oldNode = GenerateRedFinallyBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFinallyStatementRewriter()
            dim oldNode = GenerateRedFinallyStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedErrorStatementRewriter()
            dim oldNode = GenerateRedErrorStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorGoToZeroStatementRewriter()
            dim oldNode = GenerateRedOnErrorGoToZeroStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorGoToMinusOneStatementRewriter()
            dim oldNode = GenerateRedOnErrorGoToMinusOneStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorGoToLabelStatementRewriter()
            dim oldNode = GenerateRedOnErrorGoToLabelStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOnErrorResumeNextStatementRewriter()
            dim oldNode = GenerateRedOnErrorResumeNextStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedResumeStatementRewriter()
            dim oldNode = GenerateRedResumeStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedResumeLabelStatementRewriter()
            dim oldNode = GenerateRedResumeLabelStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedResumeNextStatementRewriter()
            dim oldNode = GenerateRedResumeNextStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSelectBlockRewriter()
            dim oldNode = GenerateRedSelectBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSelectStatementRewriter()
            dim oldNode = GenerateRedSelectStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseBlockRewriter()
            dim oldNode = GenerateRedCaseBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseElseBlockRewriter()
            dim oldNode = GenerateRedCaseElseBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseStatementRewriter()
            dim oldNode = GenerateRedCaseStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseElseStatementRewriter()
            dim oldNode = GenerateRedCaseElseStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseCaseClauseRewriter()
            dim oldNode = GenerateRedElseCaseClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleCaseClauseRewriter()
            dim oldNode = GenerateRedSimpleCaseClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRangeCaseClauseRewriter()
            dim oldNode = GenerateRedRangeCaseClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseEqualsClauseRewriter()
            dim oldNode = GenerateRedCaseEqualsClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseNotEqualsClauseRewriter()
            dim oldNode = GenerateRedCaseNotEqualsClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseLessThanClauseRewriter()
            dim oldNode = GenerateRedCaseLessThanClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseLessThanOrEqualClauseRewriter()
            dim oldNode = GenerateRedCaseLessThanOrEqualClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseGreaterThanOrEqualClauseRewriter()
            dim oldNode = GenerateRedCaseGreaterThanOrEqualClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCaseGreaterThanClauseRewriter()
            dim oldNode = GenerateRedCaseGreaterThanClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSyncLockStatementRewriter()
            dim oldNode = GenerateRedSyncLockStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleDoLoopBlockRewriter()
            dim oldNode = GenerateRedSimpleDoLoopBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDoWhileLoopBlockRewriter()
            dim oldNode = GenerateRedDoWhileLoopBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDoUntilLoopBlockRewriter()
            dim oldNode = GenerateRedDoUntilLoopBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDoLoopWhileBlockRewriter()
            dim oldNode = GenerateRedDoLoopWhileBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDoLoopUntilBlockRewriter()
            dim oldNode = GenerateRedDoLoopUntilBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleDoStatementRewriter()
            dim oldNode = GenerateRedSimpleDoStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDoWhileStatementRewriter()
            dim oldNode = GenerateRedDoWhileStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDoUntilStatementRewriter()
            dim oldNode = GenerateRedDoUntilStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleLoopStatementRewriter()
            dim oldNode = GenerateRedSimpleLoopStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLoopWhileStatementRewriter()
            dim oldNode = GenerateRedLoopWhileStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLoopUntilStatementRewriter()
            dim oldNode = GenerateRedLoopUntilStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWhileClauseRewriter()
            dim oldNode = GenerateRedWhileClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedUntilClauseRewriter()
            dim oldNode = GenerateRedUntilClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWhileStatementRewriter()
            dim oldNode = GenerateRedWhileStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedForBlockRewriter()
            dim oldNode = GenerateRedForBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedForEachBlockRewriter()
            dim oldNode = GenerateRedForEachBlock()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedForStatementRewriter()
            dim oldNode = GenerateRedForStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedForStepClauseRewriter()
            dim oldNode = GenerateRedForStepClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedForEachStatementRewriter()
            dim oldNode = GenerateRedForEachStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNextStatementRewriter()
            dim oldNode = GenerateRedNextStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedUsingStatementRewriter()
            dim oldNode = GenerateRedUsingStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedThrowStatementRewriter()
            dim oldNode = GenerateRedThrowStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleAssignmentStatementRewriter()
            dim oldNode = GenerateRedSimpleAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMidAssignmentStatementRewriter()
            dim oldNode = GenerateRedMidAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAddAssignmentStatementRewriter()
            dim oldNode = GenerateRedAddAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSubtractAssignmentStatementRewriter()
            dim oldNode = GenerateRedSubtractAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiplyAssignmentStatementRewriter()
            dim oldNode = GenerateRedMultiplyAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDivideAssignmentStatementRewriter()
            dim oldNode = GenerateRedDivideAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIntegerDivideAssignmentStatementRewriter()
            dim oldNode = GenerateRedIntegerDivideAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExponentiateAssignmentStatementRewriter()
            dim oldNode = GenerateRedExponentiateAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLeftShiftAssignmentStatementRewriter()
            dim oldNode = GenerateRedLeftShiftAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRightShiftAssignmentStatementRewriter()
            dim oldNode = GenerateRedRightShiftAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedConcatenateAssignmentStatementRewriter()
            dim oldNode = GenerateRedConcatenateAssignmentStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMidExpressionRewriter()
            dim oldNode = GenerateRedMidExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCallStatementRewriter()
            dim oldNode = GenerateRedCallStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAddHandlerStatementRewriter()
            dim oldNode = GenerateRedAddHandlerStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRemoveHandlerStatementRewriter()
            dim oldNode = GenerateRedRemoveHandlerStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRaiseEventStatementRewriter()
            dim oldNode = GenerateRedRaiseEventStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWithStatementRewriter()
            dim oldNode = GenerateRedWithStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedReDimStatementRewriter()
            dim oldNode = GenerateRedReDimStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedReDimPreserveStatementRewriter()
            dim oldNode = GenerateRedReDimPreserveStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRedimClauseRewriter()
            dim oldNode = GenerateRedRedimClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEraseStatementRewriter()
            dim oldNode = GenerateRedEraseStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCharacterLiteralExpressionRewriter()
            dim oldNode = GenerateRedCharacterLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTrueLiteralExpressionRewriter()
            dim oldNode = GenerateRedTrueLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFalseLiteralExpressionRewriter()
            dim oldNode = GenerateRedFalseLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNumericLiteralExpressionRewriter()
            dim oldNode = GenerateRedNumericLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDateLiteralExpressionRewriter()
            dim oldNode = GenerateRedDateLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedStringLiteralExpressionRewriter()
            dim oldNode = GenerateRedStringLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNothingLiteralExpressionRewriter()
            dim oldNode = GenerateRedNothingLiteralExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedParenthesizedExpressionRewriter()
            dim oldNode = GenerateRedParenthesizedExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTupleExpressionRewriter()
            dim oldNode = GenerateRedTupleExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTupleTypeRewriter()
            dim oldNode = GenerateRedTupleType()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypedTupleElementRewriter()
            dim oldNode = GenerateRedTypedTupleElement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNamedTupleElementRewriter()
            dim oldNode = GenerateRedNamedTupleElement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMeExpressionRewriter()
            dim oldNode = GenerateRedMeExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMyBaseExpressionRewriter()
            dim oldNode = GenerateRedMyBaseExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMyClassExpressionRewriter()
            dim oldNode = GenerateRedMyClassExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGetTypeExpressionRewriter()
            dim oldNode = GenerateRedGetTypeExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeOfIsExpressionRewriter()
            dim oldNode = GenerateRedTypeOfIsExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeOfIsNotExpressionRewriter()
            dim oldNode = GenerateRedTypeOfIsNotExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGetXmlNamespaceExpressionRewriter()
            dim oldNode = GenerateRedGetXmlNamespaceExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleMemberAccessExpressionRewriter()
            dim oldNode = GenerateRedSimpleMemberAccessExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDictionaryAccessExpressionRewriter()
            dim oldNode = GenerateRedDictionaryAccessExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementAccessExpressionRewriter()
            dim oldNode = GenerateRedXmlElementAccessExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDescendantAccessExpressionRewriter()
            dim oldNode = GenerateRedXmlDescendantAccessExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlAttributeAccessExpressionRewriter()
            dim oldNode = GenerateRedXmlAttributeAccessExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInvocationExpressionRewriter()
            dim oldNode = GenerateRedInvocationExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedObjectCreationExpressionRewriter()
            dim oldNode = GenerateRedObjectCreationExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAnonymousObjectCreationExpressionRewriter()
            dim oldNode = GenerateRedAnonymousObjectCreationExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedArrayCreationExpressionRewriter()
            dim oldNode = GenerateRedArrayCreationExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCollectionInitializerRewriter()
            dim oldNode = GenerateRedCollectionInitializer()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCTypeExpressionRewriter()
            dim oldNode = GenerateRedCTypeExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDirectCastExpressionRewriter()
            dim oldNode = GenerateRedDirectCastExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTryCastExpressionRewriter()
            dim oldNode = GenerateRedTryCastExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedPredefinedCastExpressionRewriter()
            dim oldNode = GenerateRedPredefinedCastExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAddExpressionRewriter()
            dim oldNode = GenerateRedAddExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSubtractExpressionRewriter()
            dim oldNode = GenerateRedSubtractExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiplyExpressionRewriter()
            dim oldNode = GenerateRedMultiplyExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDivideExpressionRewriter()
            dim oldNode = GenerateRedDivideExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIntegerDivideExpressionRewriter()
            dim oldNode = GenerateRedIntegerDivideExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExponentiateExpressionRewriter()
            dim oldNode = GenerateRedExponentiateExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLeftShiftExpressionRewriter()
            dim oldNode = GenerateRedLeftShiftExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRightShiftExpressionRewriter()
            dim oldNode = GenerateRedRightShiftExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedConcatenateExpressionRewriter()
            dim oldNode = GenerateRedConcatenateExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedModuloExpressionRewriter()
            dim oldNode = GenerateRedModuloExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEqualsExpressionRewriter()
            dim oldNode = GenerateRedEqualsExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNotEqualsExpressionRewriter()
            dim oldNode = GenerateRedNotEqualsExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLessThanExpressionRewriter()
            dim oldNode = GenerateRedLessThanExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLessThanOrEqualExpressionRewriter()
            dim oldNode = GenerateRedLessThanOrEqualExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGreaterThanOrEqualExpressionRewriter()
            dim oldNode = GenerateRedGreaterThanOrEqualExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGreaterThanExpressionRewriter()
            dim oldNode = GenerateRedGreaterThanExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIsExpressionRewriter()
            dim oldNode = GenerateRedIsExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIsNotExpressionRewriter()
            dim oldNode = GenerateRedIsNotExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLikeExpressionRewriter()
            dim oldNode = GenerateRedLikeExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOrExpressionRewriter()
            dim oldNode = GenerateRedOrExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExclusiveOrExpressionRewriter()
            dim oldNode = GenerateRedExclusiveOrExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAndExpressionRewriter()
            dim oldNode = GenerateRedAndExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOrElseExpressionRewriter()
            dim oldNode = GenerateRedOrElseExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAndAlsoExpressionRewriter()
            dim oldNode = GenerateRedAndAlsoExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedUnaryPlusExpressionRewriter()
            dim oldNode = GenerateRedUnaryPlusExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedUnaryMinusExpressionRewriter()
            dim oldNode = GenerateRedUnaryMinusExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNotExpressionRewriter()
            dim oldNode = GenerateRedNotExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAddressOfExpressionRewriter()
            dim oldNode = GenerateRedAddressOfExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedBinaryConditionalExpressionRewriter()
            dim oldNode = GenerateRedBinaryConditionalExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTernaryConditionalExpressionRewriter()
            dim oldNode = GenerateRedTernaryConditionalExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineFunctionLambdaExpressionRewriter()
            dim oldNode = GenerateRedSingleLineFunctionLambdaExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSingleLineSubLambdaExpressionRewriter()
            dim oldNode = GenerateRedSingleLineSubLambdaExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiLineFunctionLambdaExpressionRewriter()
            dim oldNode = GenerateRedMultiLineFunctionLambdaExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedMultiLineSubLambdaExpressionRewriter()
            dim oldNode = GenerateRedMultiLineSubLambdaExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSubLambdaHeaderRewriter()
            dim oldNode = GenerateRedSubLambdaHeader()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionLambdaHeaderRewriter()
            dim oldNode = GenerateRedFunctionLambdaHeader()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedArgumentListRewriter()
            dim oldNode = GenerateRedArgumentList()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOmittedArgumentRewriter()
            dim oldNode = GenerateRedOmittedArgument()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleArgumentRewriter()
            dim oldNode = GenerateRedSimpleArgument()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNameColonEqualsRewriter()
            dim oldNode = GenerateRedNameColonEquals()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRangeArgumentRewriter()
            dim oldNode = GenerateRedRangeArgument()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedQueryExpressionRewriter()
            dim oldNode = GenerateRedQueryExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCollectionRangeVariableRewriter()
            dim oldNode = GenerateRedCollectionRangeVariable()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExpressionRangeVariableRewriter()
            dim oldNode = GenerateRedExpressionRangeVariable()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAggregationRangeVariableRewriter()
            dim oldNode = GenerateRedAggregationRangeVariable()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedVariableNameEqualsRewriter()
            dim oldNode = GenerateRedVariableNameEquals()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFunctionAggregationRewriter()
            dim oldNode = GenerateRedFunctionAggregation()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGroupAggregationRewriter()
            dim oldNode = GenerateRedGroupAggregation()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedFromClauseRewriter()
            dim oldNode = GenerateRedFromClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedLetClauseRewriter()
            dim oldNode = GenerateRedLetClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAggregateClauseRewriter()
            dim oldNode = GenerateRedAggregateClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDistinctClauseRewriter()
            dim oldNode = GenerateRedDistinctClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedWhereClauseRewriter()
            dim oldNode = GenerateRedWhereClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSkipWhileClauseRewriter()
            dim oldNode = GenerateRedSkipWhileClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTakeWhileClauseRewriter()
            dim oldNode = GenerateRedTakeWhileClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSkipClauseRewriter()
            dim oldNode = GenerateRedSkipClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTakeClauseRewriter()
            dim oldNode = GenerateRedTakeClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGroupByClauseRewriter()
            dim oldNode = GenerateRedGroupByClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedJoinConditionRewriter()
            dim oldNode = GenerateRedJoinCondition()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSimpleJoinClauseRewriter()
            dim oldNode = GenerateRedSimpleJoinClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGroupJoinClauseRewriter()
            dim oldNode = GenerateRedGroupJoinClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedOrderByClauseRewriter()
            dim oldNode = GenerateRedOrderByClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAscendingOrderingRewriter()
            dim oldNode = GenerateRedAscendingOrdering()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDescendingOrderingRewriter()
            dim oldNode = GenerateRedDescendingOrdering()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSelectClauseRewriter()
            dim oldNode = GenerateRedSelectClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDocumentRewriter()
            dim oldNode = GenerateRedXmlDocument()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDeclarationRewriter()
            dim oldNode = GenerateRedXmlDeclaration()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlDeclarationOptionRewriter()
            dim oldNode = GenerateRedXmlDeclarationOption()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementRewriter()
            dim oldNode = GenerateRedXmlElement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlTextRewriter()
            dim oldNode = GenerateRedXmlText()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementStartTagRewriter()
            dim oldNode = GenerateRedXmlElementStartTag()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlElementEndTagRewriter()
            dim oldNode = GenerateRedXmlElementEndTag()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlEmptyElementRewriter()
            dim oldNode = GenerateRedXmlEmptyElement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlAttributeRewriter()
            dim oldNode = GenerateRedXmlAttribute()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlStringRewriter()
            dim oldNode = GenerateRedXmlString()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlPrefixNameRewriter()
            dim oldNode = GenerateRedXmlPrefixName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlNameRewriter()
            dim oldNode = GenerateRedXmlName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlBracketedNameRewriter()
            dim oldNode = GenerateRedXmlBracketedName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlPrefixRewriter()
            dim oldNode = GenerateRedXmlPrefix()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlCommentRewriter()
            dim oldNode = GenerateRedXmlComment()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlProcessingInstructionRewriter()
            dim oldNode = GenerateRedXmlProcessingInstruction()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlCDataSectionRewriter()
            dim oldNode = GenerateRedXmlCDataSection()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlEmbeddedExpressionRewriter()
            dim oldNode = GenerateRedXmlEmbeddedExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedArrayTypeRewriter()
            dim oldNode = GenerateRedArrayType()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNullableTypeRewriter()
            dim oldNode = GenerateRedNullableType()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedPredefinedTypeRewriter()
            dim oldNode = GenerateRedPredefinedType()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIdentifierNameRewriter()
            dim oldNode = GenerateRedIdentifierName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGenericNameRewriter()
            dim oldNode = GenerateRedGenericName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedQualifiedNameRewriter()
            dim oldNode = GenerateRedQualifiedName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedGlobalNameRewriter()
            dim oldNode = GenerateRedGlobalName()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedTypeArgumentListRewriter()
            dim oldNode = GenerateRedTypeArgumentList()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefReferenceRewriter()
            dim oldNode = GenerateRedCrefReference()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefSignatureRewriter()
            dim oldNode = GenerateRedCrefSignature()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefSignaturePartRewriter()
            dim oldNode = GenerateRedCrefSignaturePart()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedCrefOperatorReferenceRewriter()
            dim oldNode = GenerateRedCrefOperatorReference()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedQualifiedCrefOperatorReferenceRewriter()
            dim oldNode = GenerateRedQualifiedCrefOperatorReference()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedYieldStatementRewriter()
            dim oldNode = GenerateRedYieldStatement()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedAwaitExpressionRewriter()
            dim oldNode = GenerateRedAwaitExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedSkippedTokensTriviaRewriter()
            dim oldNode = GenerateRedSkippedTokensTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDocumentationCommentTriviaRewriter()
            dim oldNode = GenerateRedDocumentationCommentTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlCrefAttributeRewriter()
            dim oldNode = GenerateRedXmlCrefAttribute()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedXmlNameAttributeRewriter()
            dim oldNode = GenerateRedXmlNameAttribute()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedConditionalAccessExpressionRewriter()
            dim oldNode = GenerateRedConditionalAccessExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedNameOfExpressionRewriter()
            dim oldNode = GenerateRedNameOfExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolatedStringExpressionRewriter()
            dim oldNode = GenerateRedInterpolatedStringExpression()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolatedStringTextRewriter()
            dim oldNode = GenerateRedInterpolatedStringText()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolationRewriter()
            dim oldNode = GenerateRedInterpolation()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolationAlignmentClauseRewriter()
            dim oldNode = GenerateRedInterpolationAlignmentClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedInterpolationFormatClauseRewriter()
            dim oldNode = GenerateRedInterpolationFormatClause()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedConstDirectiveTriviaRewriter()
            dim oldNode = GenerateRedConstDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedIfDirectiveTriviaRewriter()
            dim oldNode = GenerateRedIfDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseIfDirectiveTriviaRewriter()
            dim oldNode = GenerateRedElseIfDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedElseDirectiveTriviaRewriter()
            dim oldNode = GenerateRedElseDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndIfDirectiveTriviaRewriter()
            dim oldNode = GenerateRedEndIfDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedRegionDirectiveTriviaRewriter()
            dim oldNode = GenerateRedRegionDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEndRegionDirectiveTriviaRewriter()
            dim oldNode = GenerateRedEndRegionDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedExternalChecksumDirectiveTriviaRewriter()
            dim oldNode = GenerateRedExternalChecksumDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedEnableWarningDirectiveTriviaRewriter()
            dim oldNode = GenerateRedEnableWarningDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedDisableWarningDirectiveTriviaRewriter()
            dim oldNode = GenerateRedDisableWarningDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedReferenceDirectiveTriviaRewriter()
            dim oldNode = GenerateRedReferenceDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
        <Fact>
        Public Sub TestRedBadDirectiveTriviaRewriter()
            dim oldNode = GenerateRedBadDirectiveTrivia()
            Dim rewriter = New RedIdentityRewriter()
            Dim newNode = rewriter.Visit(oldNode)
            Assert.Equal(oldNode, newNode)
        End Sub
 
#end region
 
End Class
End Namespace