{

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql100ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql100ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql100, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql110ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql110ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql110, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql120ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql120ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql120, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql130ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql130ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql130, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql140ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql140ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql140, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql150ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql150ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql150, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql160ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql160ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql160, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql80ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql80ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql80, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSql90ScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new Sql90ScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql90, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSqlServerlessScriptGenerator()

{

var options = new SqlScriptGeneratorOptions();

var scriptGenerator = new SqlServerlessScriptGenerator(options);

Assert.AreEqual(SqlVersion.Sql160, scriptGenerator.Options.SqlVersion);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewlinesBetweenStatementsGeneratorOption() {

var tableName = new SchemaObjectName();

tableName.Identifiers.Add(new Identifier { Value = "TableName" });

var tableStatement = new CreateTableStatement

{

SchemaObjectName = tableName

};

var tableStatementString = "CREATE TABLE TableName;";

var statements = new StatementList();

statements.Statements.Add(tableStatement);

statements.Statements.Add(tableStatement);

var generatorOptions = new SqlScriptGeneratorOptions {

KeywordCasing = KeywordCasing.Uppercase,

IncludeSemicolons = true,

NumNewlinesAfterStatement = 0

};

var generator = new Sql80ScriptGenerator(generatorOptions);

generator.GenerateScript(statements, out var sql);

Assert.AreEqual(tableStatementString + tableStatementString, sql);

generatorOptions.NumNewlinesAfterStatement = 1;

generator = new Sql80ScriptGenerator(generatorOptions);

generator.GenerateScript(statements, out sql);

Assert.AreEqual(tableStatementString + Environment.NewLine + tableStatementString, sql);

generatorOptions.NumNewlinesAfterStatement = 2;

generator = new Sql80ScriptGenerator(generatorOptions);

generator.GenerateScript(statements, out sql);

Assert.AreEqual(tableStatementString + Environment.NewLine + Environment.NewLine + tableStatementString, sql);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewLineFormattedIndexDefinitionDefault() {

Assert.AreEqual(false, new SqlScriptGeneratorOptions().NewLineFormattedIndexDefinition);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewlineFormattedCheckConstraintDefault() {

Assert.AreEqual(false, new SqlScriptGeneratorOptions().NewlineFormattedCheckConstraint);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSpaceBetweenDataTypeAndParametersDefault() {

Assert.AreEqual(true, new SqlScriptGeneratorOptions().SpaceBetweenDataTypeAndParameters);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSpaceBetweenParametersInDataTypeDefault() {

Assert.AreEqual(true, new SqlScriptGeneratorOptions().SpaceBetweenParametersInDataType);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSpaceBetweenDataTypeAndParametersWhenFalse() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

SpaceBetweenDataTypeAndParameters = false

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSpaceBetweenDataTypeAndParametersWhenTrue() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

SpaceBetweenDataTypeAndParameters = true

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSpaceBetweenParametersInDataTypeWhenFalse() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

SpaceBetweenParametersInDataType = false

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestSpaceBetweenParametersInDataTypeWhenTrue() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

SpaceBetweenParametersInDataType = true

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewlineFormattedCheckConstraintWhenFalse() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

NewlineFormattedCheckConstraint = false

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewlineFormattedCheckConstraintWhenTrue() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

NewlineFormattedCheckConstraint = true

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewLineFormattedIndexDefinitionWhenFalse() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

NewLineFormattedIndexDefinition = false

});

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestNewLineFormattedIndexDefinitionWhenTrue() {

var expectedSqlText = @"CREATE TABLE DummyTable (

ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {

NewLineFormattedIndexDefinition = true

});

}

void ParseAndAssertEquality(string sqlText, SqlScriptGeneratorOptions generatorOptions) {

var parser = new TSql160Parser(true);

var fragment = parser.ParseStatementList(new StringReader(sqlText), out var errors);

Assert.AreEqual(0, errors.Count);

var generator = new Sql160ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSqlText);

Assert.AreEqual(sqlText, generatedSqlText);

}

#region Generator Whitespace Regression Tests

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestAlterTableAddColumnThenIndex_EmitsSeparatorBeforeIndex()

{

// Verbatim sample from docs/relational-databases/in-memory-oltp/

// altering-memory-optimized-tables.md (line 119). Generator was

// omitting the separator between the trailing column constraint

// ('NOT NULL') and the inline INDEX, producing 'NOT NULLINDEX

// ix_Customer' which fails to reparse.

var sql =

"ALTER TABLE Sales.SalesOrderDetail_inmem " + Environment.NewLine +

" ADD CustomerID int NOT NULL DEFAULT -1 WITH VALUES, " + Environment.NewLine +

" ShipMethodID int NOT NULL DEFAULT -1 WITH VALUES, " + Environment.NewLine +

" INDEX ix_Customer (CustomerID); " + Environment.NewLine +

"GO " + Environment.NewLine;

var parser = new TSql170Parser(true);

TSqlFragment fragment;

IList<ParseError> parseErrors;

using (var reader = new StringReader(sql))

{

fragment = parser.Parse(reader, out parseErrors);

}

Assert.AreEqual(0, parseErrors.Count, "Input must parse.");

var generator = new Sql170ScriptGenerator(new SqlScriptGeneratorOptions

{

IncludeSemicolons = true,

});

generator.GenerateScript(fragment, out var generated);

Assert.IsFalse(generated.Contains("NULLINDEX"),

"Column constraint 'NULL' must not run into the 'INDEX' keyword. Actual:\n" + generated);

Assert.IsTrue(generated.Contains("INDEX ix_Customer"),

"INDEX keyword must be present and separated. Actual:\n" + generated);

var reparser = new TSql170Parser(true);

IList<ParseError> reparseErrors;

using (var reader = new StringReader(generated))

{

reparser.Parse(reader, out reparseErrors);

}

Assert.AreEqual(0, reparseErrors.Count,

"Generated SQL must reparse. Actual:\n" + generated);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestAlterTableAddIndexOnly_EmitsNoLeadingSeparator()

{

// Verbatim sample from docs/relational-databases/in-memory-oltp/

// altering-memory-optimized-tables.md (line 111). With no preceding

// column or constraint, the generator must NOT emit a leading

// comma before the INDEX (which would produce invalid syntax).

var sql =

"ALTER TABLE Sales.SalesOrderDetail_inmem " + Environment.NewLine +

" ADD INDEX ix_ModifiedDate (ModifiedDate); " + Environment.NewLine +

"GO " + Environment.NewLine;

var parser = new TSql170Parser(true);

TSqlFragment fragment;

IList<ParseError> parseErrors;

using (var reader = new StringReader(sql))

{

fragment = parser.Parse(reader, out parseErrors);

}

Assert.AreEqual(0, parseErrors.Count, "Input must parse.");

var generator = new Sql170ScriptGenerator(new SqlScriptGeneratorOptions

{

IncludeSemicolons = true,

});

generator.GenerateScript(fragment, out var generated);

Assert.IsFalse(generated.Contains("ADD ,") || generated.Contains("ADD\n,"),

"ADD must not be followed by a stray separator. Actual:\n" + generated);

Assert.IsTrue(generated.Contains("ADD INDEX ix_ModifiedDate"),

"INDEX clause must follow ADD directly. Actual:\n" + generated);

var reparser = new TSql170Parser(true);

IList<ParseError> reparseErrors;

using (var reader = new StringReader(generated))

{

reparser.Parse(reader, out reparseErrors);

}

Assert.AreEqual(0, reparseErrors.Count,

"Generated SQL must reparse. Actual:\n" + generated);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestWindowDefinition_RefWindowFollowedByPartitionByEmitsSpace()

{

// Verbatim sample from docs/t-sql/queries/select-window-transact-sql.md

// (line 312). Generator was emitting 'win2PARTITION' (no space)

// because the visitor didn't separate the inherited window-name

// reference from the PARTITION keyword.

var sql =

"ALTER DATABASE AdventureWorks2025" + Environment.NewLine +

"SET COMPATIBILITY_LEVEL = 160;" + Environment.NewLine +

"GO" + Environment.NewLine +

Environment.NewLine +

"USE AdventureWorks2025;" + Environment.NewLine +

"GO" + Environment.NewLine +

Environment.NewLine +

"SELECT SalesOrderID AS OrderNumber," + Environment.NewLine +

" ProductID," + Environment.NewLine +

" OrderQty AS Qty," + Environment.NewLine +

" SUM(OrderQty) OVER win2 AS Total," + Environment.NewLine +

" AVG(OrderQty) OVER win1 AS Avg" + Environment.NewLine +

"FROM Sales.SalesOrderDetail" + Environment.NewLine +

"WHERE SalesOrderID IN (43659, 43664)" + Environment.NewLine +

" AND ProductID LIKE '71%'" + Environment.NewLine +

"WINDOW win1 AS (win3)," + Environment.NewLine +

" win2 AS (ORDER BY SalesOrderID, ProductID)," + Environment.NewLine +

" win3 AS (win2 PARTITION BY SalesOrderID);" + Environment.NewLine;

var parser = new TSql170Parser(true);

TSqlFragment fragment;

IList<ParseError> parseErrors;

using (var reader = new StringReader(sql))

{

fragment = parser.Parse(reader, out parseErrors);

}

Assert.AreEqual(0, parseErrors.Count, "Input must parse.");

var generator = new Sql170ScriptGenerator(new SqlScriptGeneratorOptions

{

IncludeSemicolons = true,

});

generator.GenerateScript(fragment, out var generated);

Assert.IsFalse(generated.Contains("win2PARTITION"),

"Window-name reference must not run into PARTITION keyword. Actual:\n" + generated);

Assert.IsTrue(generated.Contains("win2 PARTITION"),

"Generated window must read 'win2 PARTITION'. Actual:\n" + generated);

var reparser = new TSql170Parser(true);

IList<ParseError> reparseErrors;

using (var reader = new StringReader(generated))

{

reparser.Parse(reader, out reparseErrors);

}

Assert.AreEqual(0, reparseErrors.Count,

"Generated SQL must reparse. Actual:\n" + generated);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestWindowDefinition_RefWindowFollowedByOrderByEmitsSpace()

{

// Same bug class as above, exercised through the ORDER BY branch.

// 'WINDOW name AS (refname ORDER BY ...)' must not emit

// 'refnameORDER'. This shape isn't in the docs but the same code

// path can produce it; included as belt-and-suspenders coverage.

var sql =

"SELECT SalesOrderID, SUM(OrderQty) OVER win2 AS Total" + Environment.NewLine +

"FROM Sales.SalesOrderDetail" + Environment.NewLine +

"WINDOW win1 AS (PARTITION BY ProductID)," + Environment.NewLine +

" win2 AS (win1 ORDER BY SalesOrderID);";

var parser = new TSql170Parser(true);

TSqlFragment fragment;

IList<ParseError> parseErrors;

using (var reader = new StringReader(sql))

{

fragment = parser.Parse(reader, out parseErrors);

}

Assert.AreEqual(0, parseErrors.Count, "Input must parse.");

var generator = new Sql170ScriptGenerator(new SqlScriptGeneratorOptions

{

IncludeSemicolons = true,

});

generator.GenerateScript(fragment, out var generated);

Assert.IsFalse(generated.Contains("win1ORDER"),

"Window-name reference must not run into ORDER keyword. Actual:\n" + generated);

Assert.IsTrue(generated.Contains("win1 ORDER"),

"Generated window must read 'win1 ORDER'. Actual:\n" + generated);

var reparser = new TSql170Parser(true);

IList<ParseError> reparseErrors;

using (var reader = new StringReader(generated))

{

reparser.Parse(reader, out reparseErrors);

}

Assert.AreEqual(0, reparseErrors.Count,

"Generated SQL must reparse. Actual:\n" + generated);

}

#endregion

#region Comment Preservation Tests

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsDefault()

{

// Verify default is false

var options = new SqlScriptGeneratorOptions();

Assert.AreEqual(false, options.PreserveComments);

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsDisabled()

{

// When PreserveComments is false (default), comments should be stripped

var sqlWithComments = "-- This is a leading comment\nSELECT 1; -- trailing comment";

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = false // default

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// Without PreserveComments, comments should not appear

Assert.IsFalse(generatedSql.Contains("--"), "Comments should be stripped when PreserveComments is false");

Assert.IsFalse(generatedSql.Contains("leading comment"), "Comment text should not appear");

Assert.IsFalse(generatedSql.Contains("trailing comment"), "Trailing comment should not appear");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_SingleLineLeading()

{

// When PreserveComments is true, leading single-line comments should be preserved

var sqlWithComments = "-- This is a leading comment\nSELECT 1;";

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// With PreserveComments, the comment should appear in output

Assert.IsTrue(generatedSql.Contains("-- This is a leading comment"),

"Leading comment should be preserved when PreserveComments is true");

// Verify comment appears BEFORE the SELECT keyword (correct positioning)

int commentIndex = generatedSql.IndexOf("-- This is a leading comment");

int selectIndex = generatedSql.IndexOf("SELECT", StringComparison.OrdinalIgnoreCase);

Assert.IsTrue(commentIndex < selectIndex,

$"Leading comment should appear before SELECT. Comment at {commentIndex}, SELECT at {selectIndex}");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_SingleLineTrailing()

{

// When PreserveComments is true, trailing single-line comments should be preserved

var sqlWithComments = "SELECT 1; -- trailing comment";

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// With PreserveComments, the trailing comment should appear

Assert.IsTrue(generatedSql.Contains("-- trailing comment"),

"Trailing comment should be preserved when PreserveComments is true");

// Verify trailing comment appears AFTER the SELECT (correct positioning)

int selectIndex = generatedSql.IndexOf("SELECT", StringComparison.OrdinalIgnoreCase);

int commentIndex = generatedSql.IndexOf("-- trailing comment");

Assert.IsTrue(commentIndex > selectIndex,

$"Trailing comment should appear after SELECT. SELECT at {selectIndex}, comment at {commentIndex}");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_MultipleStatements()

{

// Test comments between multiple statements

var sqlWithComments = @"-- First statement

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// Both comments should be preserved

Assert.IsTrue(generatedSql.Contains("-- First statement"),

"First comment should be preserved");

Assert.IsTrue(generatedSql.Contains("-- Comment between statements"),

"Comment between statements should be preserved");

// Verify ordering: first comment -> SELECT 1 -> between comment -> SELECT 2

int firstCommentIndex = generatedSql.IndexOf("-- First statement");

int firstSelectIndex = generatedSql.IndexOf("SELECT 1", StringComparison.OrdinalIgnoreCase);

int betweenCommentIndex = generatedSql.IndexOf("-- Comment between statements");

int secondSelectIndex = generatedSql.IndexOf("SELECT 2", StringComparison.OrdinalIgnoreCase);

Assert.IsTrue(firstCommentIndex < firstSelectIndex,

"First comment should appear before first SELECT");

Assert.IsTrue(firstSelectIndex < betweenCommentIndex,

"Between comment should appear after first SELECT");

Assert.IsTrue(betweenCommentIndex < secondSelectIndex,

"Between comment should appear before second SELECT");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_MultiLineComment()

{

// When PreserveComments is true, multi-line comments should be preserved

var sqlWithComments = "/* This is a multi-line comment */\nSELECT 1;";

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// With PreserveComments, the multi-line comment should appear

Assert.IsTrue(generatedSql.Contains("/* This is a multi-line comment */"),

"Multi-line comment should be preserved when PreserveComments is true");

// Verify comment appears BEFORE the SELECT keyword (correct positioning)

int commentIndex = generatedSql.IndexOf("/* This is a multi-line comment */");

int selectIndex = generatedSql.IndexOf("SELECT", StringComparison.OrdinalIgnoreCase);

Assert.IsTrue(commentIndex < selectIndex,

$"Multi-line comment should appear before SELECT. Comment at {commentIndex}, SELECT at {selectIndex}");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_MultiLineBlockComment()

{

// Test that decorative patterns are preserved

var sqlWithComments = @"/***** Header Comment *****/

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// Decorative pattern should be preserved exactly

Assert.IsTrue(generatedSql.Contains("/***** Header Comment *****/"),

"Decorative comment pattern should be preserved exactly");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_Subquery()

{

// Test comments with subqueries

var sqlWithComments = @"-- Outer query comment

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// Outer comment should be preserved

Assert.IsTrue(generatedSql.Contains("-- Outer query comment"),

"Outer query comment should be preserved");

// Verify comment appears BEFORE the SELECT keyword (correct positioning)

int commentIndex = generatedSql.IndexOf("-- Outer query comment");

int selectIndex = generatedSql.IndexOf("SELECT", StringComparison.OrdinalIgnoreCase);

Assert.IsTrue(commentIndex < selectIndex,

$"Outer query comment should appear before SELECT. Comment at {commentIndex}, SELECT at {selectIndex}");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_CTE()

{

// Test comments with Common Table Expressions

var sqlWithComments = @"-- CTE definition comment

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// CTE comment should be preserved AND appear before the WITH keyword

Assert.IsTrue(generatedSql.Contains("-- CTE definition comment"),

"CTE definition comment should be preserved");

// Verify comment appears BEFORE the WITH keyword (correct positioning)

int commentIndex = generatedSql.IndexOf("-- CTE definition comment");

int withIndex = generatedSql.IndexOf("WITH", StringComparison.OrdinalIgnoreCase);

Assert.IsTrue(commentIndex < withIndex,

$"CTE comment should appear before WITH keyword. Comment at {commentIndex}, WITH at {withIndex}");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_InsertSelect()

{

// Test comments with INSERT...SELECT statements

var sqlWithComments = @"-- Insert with select comment

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);

generator.GenerateScript(fragment, out var generatedSql);

// Insert comment should be preserved

Assert.IsTrue(generatedSql.Contains("-- Insert with select comment"),

"Insert statement comment should be preserved");

// Verify comment appears BEFORE the INSERT keyword (correct positioning)

int commentIndex = generatedSql.IndexOf("-- Insert with select comment");

int insertIndex = generatedSql.IndexOf("INSERT", StringComparison.OrdinalIgnoreCase);

Assert.IsTrue(commentIndex < insertIndex,

$"Insert comment should appear before INSERT. Comment at {commentIndex}, INSERT at {insertIndex}");

}

[TestMethod]

[Priority(0)]

[SqlStudioTestCategory(Category.UnitTest)]

public void TestPreserveCommentsEnabled_StoredProcedure()

{

// Test comments within stored procedure body

var sqlWithComments = @"-- Procedure header comment

var parser = new TSql170Parser(true);

var fragment = parser.Parse(new StringReader(sqlWithComments), out var errors);

Assert.AreEqual(0, errors.Count);

var generatorOptions = new SqlScriptGeneratorOptions

{

PreserveComments = true

};

var generator = new Sql170ScriptGenerator(generatorOptions);