public void ArrayImplicit_Initializer_OpenBraceOnSameLine_Enter()
{
var code = @"class C
{
public void man()
{
int[] arr = $$
}
}";
var expected = @"class C
{
public void man()
{
int[] arr = {
}
}
}";
var globalOptions = new OptionsCollection(LanguageNames.CSharp)
{
{ CSharpFormattingOptions2.NewLinesForBracesInObjectCollectionArrayInitializers, false }
};
using var session = CreateSession(code, globalOptions);
Assert.NotNull(session);
CheckStart(session.Session);
CheckReturn(session.Session, 12, expected);
}
public void BlockIndentationWithAutomaticBraceFormattingDisabled()
{
var code = @"class C
{
public void X()
$$
}";
var expected = @"class C
{
public void X()
{}
}";
var expectedAfterReturn = @"class C
{
public void X()
{
}
}";
var globalOptions = new OptionsCollection(LanguageNames.CSharp)
{
{ AutoFormattingOptionsStorage.FormatOnCloseBrace, false },
{ FormattingOptions2.SmartIndent, FormattingOptions2.IndentStyle.Block },
};
using var session = CreateSession(code, globalOptions);
Assert.NotNull(session);
CheckStart(session.Session);
Assert.Equal(expected, session.Session.SubjectBuffer.CurrentSnapshot.GetText());
CheckReturn(session.Session, 4, expectedAfterReturn);
}
public void BlockIndentationWithAutomaticBraceFormatting()
{
var code = @"namespace NS1
{
public class C1
$$
}";
var expected = @"namespace NS1
{
public class C1
{ }
}";
var expectedAfterReturn = @"namespace NS1
{
public class C1
{
}
}";
var globalOptions = new OptionsCollection(LanguageNames.CSharp)
{
{ FormattingOptions2.SmartIndent, FormattingOptions2.IndentStyle.Block },
};
using var session = CreateSession(code, globalOptions);
Assert.NotNull(session);
CheckStart(session.Session);
Assert.Equal(expected, session.Session.SubjectBuffer.CurrentSnapshot.GetText());
CheckReturn(session.Session, 8, expectedAfterReturn);
}
internal static async Task TestChangeSignatureViaCommandAsync(
string languageName,
string markup,
bool expectedSuccess = true,
int[] updatedSignature = null,
string expectedUpdatedInvocationDocumentCode = null,
ChangeSignatureFailureKind?expectedFailureReason = null,
int?totalParameters = null,
bool verifyNoDiagnostics = false,
ParseOptions parseOptions = null,
OptionsCollection options = null,
int expectedSelectedIndex = -1
) =>
await TestChangeSignatureViaCommandAsync(
languageName,
markup,
updatedSignature?.Select(i => new AddedParameterOrExistingIndex(i)).ToArray(),
expectedSuccess,
expectedUpdatedInvocationDocumentCode,
expectedFailureReason,
totalParameters,
verifyNoDiagnostics,
parseOptions,
options,
expectedSelectedIndex
);
private void OnRemoveOptionClick(object sender, RoutedEventArgs e)
{
ValidateDeleteButton();
if (OptionsCollection.Any() && IsSelectedItem())
{
var index = expressionsListBox.SelectedIndex;
OptionsCollection.RemoveAt(index);
var count = OptionsCollection.Count;
if (count > 0)
{
if (index >= count)
{
index = count - 1;
}
expressionsListBox.SelectedIndex = index;
}
else
{
if (!string.IsNullOrEmpty(_expressionEditor.ExpressionText))
{
_expressionEditor.ExpressionText = string.Empty;
}
}
}
}
public static ChangeSignatureTestState Create(
string markup,
string languageName,
ParseOptions parseOptions = null,
OptionsCollection options = null
)
{
var workspace = languageName switch
{
"XML" => TestWorkspace.Create(markup, composition: s_composition),
LanguageNames.CSharp
=> TestWorkspace.CreateCSharp(
markup,
composition: s_composition,
parseOptions: (CSharpParseOptions)parseOptions
),
LanguageNames.VisualBasic
=> TestWorkspace.CreateVisualBasic(
markup,
composition: s_composition,
parseOptions: parseOptions,
compilationOptions: new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary
)
),
_ => throw new ArgumentException("Invalid language name.")
};
if (options != null)
{
workspace.ApplyOptions(options);
}
return(new ChangeSignatureTestState(workspace));
}
internal static async Task TestChangeSignatureViaCommandAsync(
string languageName,
string markup,
AddedParameterOrExistingIndex[] updatedSignature,
bool expectedSuccess = true,
string expectedUpdatedInvocationDocumentCode = null,
string expectedErrorText = null,
int?totalParameters = null,
bool verifyNoDiagnostics = false,
ParseOptions parseOptions = null,
OptionsCollection options = null,
int expectedSelectedIndex = -1)
{
using (var testState = ChangeSignatureTestState.Create(markup, languageName, parseOptions, options))
{
testState.TestChangeSignatureOptionsService.UpdatedSignature = updatedSignature;
var result = testState.ChangeSignature();
if (expectedSuccess)
{
Assert.True(result.Succeeded);
Assert.Null(testState.ErrorMessage);
}
else
{
Assert.False(result.Succeeded);
if (expectedErrorText != null)
{
Assert.Equal(expectedErrorText, testState.ErrorMessage);
Assert.Equal(NotificationSeverity.Error, testState.ErrorSeverity);
}
}
// Allow testing of invocation document regardless of success/failure
if (expectedUpdatedInvocationDocumentCode != null)
{
var updatedInvocationDocument = result.UpdatedSolution.GetDocument(testState.InvocationDocument.Id);
var updatedCode = (await updatedInvocationDocument.GetTextAsync()).ToString();
Assert.Equal(expectedUpdatedInvocationDocumentCode, updatedCode);
}
if (verifyNoDiagnostics)
{
var diagnostics = (await testState.InvocationDocument.GetSemanticModelAsync()).GetDiagnostics();
if (diagnostics.Length > 0)
{
Assert.True(false, CreateDiagnosticsString(diagnostics, updatedSignature, testState.InvocationDocument, totalParameters, (await testState.InvocationDocument.GetTextAsync()).ToString()));
}
}
if (expectedSelectedIndex != -1)
{
var parameterConfiguration = await testState.GetParameterConfigurationAsync();
Assert.Equal(expectedSelectedIndex, parameterConfiguration.SelectedIndex);
}
}
}
public async Task FormatSpanNullReference02()
{
var code =
@"class C/*1*/
{
void F()
{
System.Console.WriteLine();
}
}/*2*/";
var expected =
@"class C
{
void F()
{
System.Console.WriteLine();
}
}";
var changingOptions = new OptionsCollection(LanguageNames.CSharp)
{
{ CSharpFormattingOptions2.WrappingPreserveSingleLine, false }
};
await AssertFormatAsync(code, expected, changedOptionSet : changingOptions);
}
public void ExtensionWithPositionalAndAssignmentOptions()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Value,Property='Some Value'}");
var options = new OptionsCollection {
new PositionalOption("Value"), new PropertyOption("Property", new StringNode("Some Value"))
};
Assert.AreEqual(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
private protected Task TestAllWrappingCasesAsync(
string input,
OptionsCollection options,
params string[] outputs)
{
var parameters = new TestParameters(options: options);
return(TestAllInRegularAndScriptAsync(input, parameters, outputs));
}
public void PropertyWithMoreThanOneSpaceBetweenTokensPropertiesOnly()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Property = SomeValue }");
var options = new OptionsCollection {
new PropertyOption("Property", new StringNode("SomeValue"))
};
Assert.Equal(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
public async Task FormatRelationalPatterns1(
[CombinatorialValues("<", "<=", ">", ">=")] string operatorText,
BinaryOperatorSpacingOptions spacing)
{
var content = $@"
class A
{{
bool Method(int value)
{{
return value is {operatorText} 3 or {operatorText} 5;
}}
}}
";
var expectedSingle = $@"
class A
{{
bool Method(int value)
{{
return value is {operatorText} 3 or {operatorText} 5;
}}
}}
";
var expectedIgnore = $@"
class A
{{
bool Method(int value)
{{
return value is {operatorText} 3 or {operatorText} 5;
}}
}}
";
var expectedRemove = $@"
class A
{{
bool Method(int value)
{{
return value is {operatorText}3 or {operatorText}5;
}}
}}
";
var expected = spacing switch
{
BinaryOperatorSpacingOptions.Single => expectedSingle,
BinaryOperatorSpacingOptions.Ignore => expectedIgnore,
BinaryOperatorSpacingOptions.Remove => expectedRemove,
_ => throw ExceptionUtilities.Unreachable,
};
var changingOptions = new OptionsCollection(LanguageNames.CSharp)
{
{ CSharpFormattingOptions2.SpacingAroundBinaryOperator, spacing },
};
await AssertFormatAsync(expected, content, changedOptionSet : changingOptions);
}
private protected Task AssertNoFormattingChangesAsync(
string code,
bool debugMode = false,
OptionsCollection changedOptionSet = null,
bool testWithTransformation = true,
ParseOptions parseOptions = null)
{
return(AssertFormatAsync(code, code, SpecializedCollections.SingletonEnumerable(new TextSpan(0, code.Length)), debugMode, changedOptionSet, testWithTransformation, parseOptions));
}
public void PropertyWithDirectValueAndSpaces()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Property = SomeValue }");
var options = new OptionsCollection {
new PropertyOption("Property", new StringNode("SomeValue"))
};
Assert.Equal(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
public void ExtensionWithTwoPositionalOptions()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Value1,Value2}");
var options = new OptionsCollection {
new PositionalOption("Value1"), new PositionalOption("Value2")
};
Assert.AreEqual(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
public void ExtensionWithDottedPositionalOption()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Direct.Value}");
var options = new OptionsCollection {
new PositionalOption("Direct.Value"),
};
Assert.AreEqual(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
public void PositionalWithSpecialChars()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Binding Foo^.Bar}");
var options = new OptionsCollection {
new PositionalOption("Foo^.Bar")
};
Assert.Equal(new MarkupExtensionNode(new IdentifierNode("BindingExtension"), options), actual);
}
public void SaveConfiguration(OptionsCollection options)
{
var serializableOptions = new SerializableOptionsCollection(options);
using (var f = File.Open(_configFilename, FileMode.Create))
{
_serializer.Serialize(f, serializableOptions);
}
}
internal IpV6MobilityOptions Pad(int paddingSize)
{
if (paddingSize == 0)
{
return(this);
}
return(new IpV6MobilityOptions(
OptionsCollection.Concat(paddingSize == 1 ? (IpV6MobilityOption) new IpV6MobilityOptionPad1() : new IpV6MobilityOptionPadN(paddingSize - 2)),
IsValid));
}
private void OnPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var fe = (FrameworkElement)sender;
var index = OptionsCollection.IndexOf((StyleOption)fe.DataContext);
if (index >= 0)
{
expressionsListBox.SelectedIndex = index;
}
}
public SerializableOptionsCollection(OptionsCollection options)
{
SerializableOptions = new List <SerializableOption>();
SerializableOptions.Capacity = options.Count;
foreach (var opt in options)
{
SerializableOptions.Add(new SerializableOption(opt.Key, opt.Value));
}
}
public OptionsCollection ToOptionsCollection()
{
var r = new OptionsCollection();
foreach (var opt in SerializableOptions)
{
r.Add(opt.OptionName, opt.OptionValue);
}
return(r);
}
private protected Task AssertFormatAsync(
string expected,
string code,
IEnumerable <TextSpan> spans,
bool debugMode = false,
OptionsCollection changedOptionSet = null,
bool testWithTransformation = true,
ParseOptions parseOptions = null)
{
return(AssertFormatAsync(expected, code, spans, LanguageNames.CSharp, debugMode, changedOptionSet, testWithTransformation, parseOptions));
}
internal IpV6Options Pad(int paddingSize)
{
if (paddingSize == 0)
{
return(this);
}
IEnumerable <IpV6Option> paddedOptions =
OptionsCollection.Concat(paddingSize == 1 ? (IpV6Option) new IpV6OptionPad1() : new IpV6OptionPadN(paddingSize - 2));
return(new IpV6Options(new Tuple <IList <IpV6Option>, bool>(paddedOptions.ToList(), IsValid)));
}
internal Task TestAllOptionsOffAsync(
string initialMarkup, string expectedMarkup,
ParseOptions parseOptions = null,
CompilationOptions compilationOptions = null,
int index = 0, OptionsCollection options = null)
{
options = options ?? new OptionsCollection(GetLanguage());
options.AddRange(AllOptionsOff);
return(TestAsync(initialMarkup, expectedMarkup,
parseOptions, compilationOptions, index, options));
}
private void OnAddOptionClick(object sender, RoutedEventArgs e)
{
var opt = new StyleOption
{
Name = NewExpressionString
};
OptionsCollection.Add(opt);
expressionsListBox.SelectedIndex = OptionsCollection.Count - 1;
expressionsListBox.ScrollIntoView(opt);
ValidateDeleteButton();
}
public void ParsePositionalAndPropertyOptions()
{
var actual = MarkupExtensionParser.Options.Parse("value1,Property1=Value1,Property2='Some value'");
var expected = new OptionsCollection(new List <Option>
{
new PositionalOption("value1"),
new PropertyOption("Property1", new StringNode("Value1")),
new PropertyOption("Property2", new StringNode("Some value"))
});
Assert.AreEqual(actual, expected);
}
public override void LoadConfiguration()
{
_lock.EnterWriteLock();
try
{
_options = _configStore.LoadConfiguration();
}
finally
{
_lock.ExitWriteLock();
}
}
public EventHookupTestState(XElement workspaceElement, OptionsCollection options)
: base(workspaceElement, GetExtraParts())
{
_commandHandler = new EventHookupCommandHandler(
Workspace.ExportProvider.GetExportedValue <IThreadingContext>(),
Workspace.GetService <IInlineRenameService>(),
Workspace.ExportProvider.GetExportedValue <IAsynchronousOperationListenerProvider>(),
Workspace.ExportProvider.GetExportedValue <EventHookupSessionManager>());
_testSessionHookupMutex = new Mutex(false);
_commandHandler.TESTSessionHookupMutex = _testSessionHookupMutex;
Workspace.ApplyOptions(options);
}
internal OptionsCollection MergeStyles(OptionsCollection first, OptionsCollection second)
{
var firstPreferences = (NamingStylePreferences)first.First().Value;
var secondPreferences = (NamingStylePreferences)second.First().Value;
return(new OptionsCollection(_languageName)
{
{ NamingStyleOptions.NamingPreferences, new NamingStylePreferences(
firstPreferences.SymbolSpecifications.AddRange(secondPreferences.SymbolSpecifications),
firstPreferences.NamingStyles.AddRange(secondPreferences.NamingStyles),
firstPreferences.NamingRules.AddRange(secondPreferences.NamingRules)) }
});
}
public void ParsePositionalAndPropertyOptions()
{
var actual = MarkupExtensionParser.Options.Parse("value1,Property1=Value1,Property2='Some value'");
var expected = new OptionsCollection(new List<Option>
{
new PositionalOption("value1"),
new PropertyOption("Property1", new StringNode("Value1")),
new PropertyOption("Property2", new StringNode("Some value"))
});
Assert.AreEqual(actual, expected);
}
public void ExtensionWithTwoPositionalOptions()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Value1,Value2}");
var options = new OptionsCollection { new PositionalOption("Value1"), new PositionalOption("Value2") };
Assert.AreEqual(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
public MarkupExtensionNode(IdentifierNode identifier, OptionsCollection options)
{
Options = new OptionsCollection(options);
Identifier = identifier;
}
public void ExtensionWithDottedPositionalOption()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Direct.Value}");
var options = new OptionsCollection { new PositionalOption("Direct.Value"), };
Assert.AreEqual(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
public void ExtensionWithPositionalAndAssignmentOptions()
{
var actual = MarkupExtensionParser.MarkupExtension.Parse("{Dummy Value,Property='Some Value'}");
var options = new OptionsCollection { new PositionalOption("Value"), new PropertyOption("Property", new StringNode("Some Value")) };
Assert.AreEqual(new MarkupExtensionNode(new IdentifierNode("DummyExtension"), options), actual);
}
/// <summary>
/// Creates a new HTML select element.
/// </summary>
internal HTMLSelectElement()
: base(Tags.Select)
{
_options = new OptionsCollection(this);
WillValidate = true;
}