public object Initialize(JToken arg)
{
/* We want to support the hover capability. When we get a hover request we will respond
* with the appropriate text.
* Check the client's declared capabilities to identify what hover format the client expects
* before returning a hover response from the server. Stash away the expected format for use
* when composing the hover response.
*/
var b = arg.ToObject <InitializeParams>();
MarkupKind[] m = b.Capabilities.TextDocument.Hover.ContentFormat;
// in the case of Visual Studio, this is what I am observing. Capturing that as an assertion
// just in case things change.
System.Diagnostics.Debug.Assert(m != null &&
m.Length == 1 &&
m[0] == MarkupKind.PlainText);
HoverContentFormat = m[0];
/*
*"hover" is the only capability that we wil report back as supported.
*/
var capabilities = new ServerCapabilities();
capabilities.HoverProvider = true;
var result = new InitializeResult();
result.Capabilities = capabilities;
Initialized?.Invoke(this, new EventArgs());
return(result);
}
public object Initialize(JToken arg)
{
Log(Methods.InitializeName, arg);
var capabilities = new ServerCapabilities();
capabilities.TextDocumentSync = new TextDocumentSyncOptions();
capabilities.TextDocumentSync.OpenClose = true;
capabilities.TextDocumentSync.Change = TextDocumentSyncKind.Full;
capabilities.CompletionProvider = new CompletionOptions();
capabilities.CompletionProvider.ResolveProvider = false;
capabilities.CompletionProvider.TriggerCharacters = new string[] { ",", "." };
capabilities.CodeActionProvider = true;
capabilities.SignatureHelpProvider = new SignatureHelpOptions();
capabilities.SignatureHelpProvider.TriggerCharacters = new string [] { "(" };
capabilities.DefinitionProvider = true;
capabilities.ReferencesProvider = true;
capabilities.HoverProvider = true;
capabilities.WorkspaceSymbolProvider = true;
var result = new InitializeResult();
result.Capabilities = capabilities;
return(result);
}
public object Initialize(JToken arg)
{
if (trace)
{
System.Console.Error.WriteLine("<-- Initialize");
System.Console.Error.WriteLine(arg.ToString());
}
ServerCapabilities capabilities = new ServerCapabilities
{
TextDocumentSync = new TextDocumentSyncOptions
{
OpenClose = true,
Change = TextDocumentSyncKind.Incremental,
Save = new SaveOptions
{
IncludeText = true
}
},
HoverProvider = true,
CompletionProvider = new CompletionOptions
{
ResolveProvider = true,
TriggerCharacters = new string[] { ",", "." }
},
ReferencesProvider = true,
DefinitionProvider = true,
TypeDefinitionProvider = false, // Does not make sense for Antlr.
ImplementationProvider = false, // Does not make sense for Antlr.
DocumentHighlightProvider = true,
DocumentSymbolProvider = true,
WorkspaceSymbolProvider = false,
DocumentFormattingProvider = true,
DocumentRangeFormattingProvider = false,
RenameProvider = true
};
InitializeResult result = new InitializeResult
{
Capabilities = capabilities
};
string json = JsonConvert.SerializeObject(result);
if (trace)
{
System.Console.Error.WriteLine("--> " + json);
}
return(result);
}
public void SimpleTest(string expected)
{
var model = new ServerCapabilities {
CodeActionProvider = true,
CodeLensProvider = new CodeLensRegistrationOptions.StaticOptions {
ResolveProvider = true,
},
CompletionProvider = new CompletionRegistrationOptions.StaticOptions {
ResolveProvider = true,
TriggerCharacters = new[] { "a", "b", "c" }
},
DefinitionProvider = true,
DocumentFormattingProvider = true,
DocumentHighlightProvider = true,
DocumentLinkProvider = new DocumentLinkRegistrationOptions.StaticOptions {
ResolveProvider = true
},
DocumentOnTypeFormattingProvider = new DocumentOnTypeFormattingRegistrationOptions.StaticOptions {
FirstTriggerCharacter = ".",
MoreTriggerCharacter = new[] { ";", " " }
},
DocumentRangeFormattingProvider = true,
DocumentSymbolProvider = true,
ExecuteCommandProvider = new ExecuteCommandRegistrationOptions.StaticOptions {
Commands = new[] { "command1", "command2" }
},
Experimental = new Dictionary <string, JToken> {
{ "abc", "123" }
},
HoverProvider = true,
ReferencesProvider = true,
RenameProvider = true,
SignatureHelpProvider = new SignatureHelpRegistrationOptions.StaticOptions {
TriggerCharacters = new[] { ";", " " }
},
TextDocumentSync = new TextDocumentSync(
new TextDocumentSyncOptions {
Change = TextDocumentSyncKind.Full,
OpenClose = true,
Save = new SaveOptions {
IncludeText = true
},
WillSave = true,
WillSaveWaitUntil = true
}
),
WorkspaceSymbolProvider = true,
ColorProvider = true,
FoldingRangeProvider = true,
ImplementationProvider = true,
TypeDefinitionProvider = true
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <ServerCapabilities>(expected);
deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality());
}
public ApplicationTestDataGenerator(int randomStart)
{
this._randomStart = randomStart;
_serverCapabilities = new ServerCapabilities();
_randomSource = new RandomSource(randomStart);
_dataGenerator = new DataGenerator(_randomSource);
}
public ExtendableServerCapabilities(ServerCapabilities inner, IEnumerable<IRegistrationExtension> registrationExtensions)
{
FoldingRangeProvider = inner.FoldingRangeProvider;
ColorProvider = inner.ColorProvider;
ImplementationProvider = inner.ImplementationProvider;
TypeDefinitionProvider = inner.TypeDefinitionProvider;
Experimental = inner.Experimental;
ExecuteCommandProvider = inner.ExecuteCommandProvider;
DocumentLinkProvider = inner.DocumentLinkProvider;
RenameProvider = inner.RenameProvider;
DocumentOnTypeFormattingProvider = inner.DocumentOnTypeFormattingProvider;
DocumentRangeFormattingProvider = inner.DocumentRangeFormattingProvider;
DeclarationProvider = inner.DeclarationProvider;
DocumentFormattingProvider = inner.DocumentFormattingProvider;
CodeActionProvider = inner.CodeActionProvider;
WorkspaceSymbolProvider = inner.WorkspaceSymbolProvider;
DocumentSymbolProvider = inner.DocumentSymbolProvider;
DocumentHighlightProvider = inner.DocumentHighlightProvider;
ReferencesProvider = inner.ReferencesProvider;
DefinitionProvider = inner.DefinitionProvider;
SignatureHelpProvider = inner.SignatureHelpProvider;
CompletionProvider = inner.CompletionProvider;
HoverProvider = inner.HoverProvider;
TextDocumentSync = inner.TextDocumentSync;
CodeLensProvider = inner.CodeLensProvider;
Workspace = inner.Workspace;
CapabilityExtensions = new Dictionary<string, object>(StringComparer.Ordinal);
foreach (var registrationExtension in registrationExtensions)
{
var optionsResult = registrationExtension.GetRegistration();
CapabilityExtensions[optionsResult.ServerCapability] = optionsResult.Options;
}
}
protected async Task OneTimeSetUp()
{
// start GDS first clean, then restart server
// to ensure the application cert is not 'fresh'
_server = await TestUtils.StartGDS(true);
_server.StopServer();
await Task.Delay(1000);
_server = await TestUtils.StartGDS(false);
_serverCapabilities = new ServerCapabilities();
_randomSource = new RandomSource(randomStart);
_dataGenerator = new DataGenerator(_randomSource);
// load clients
_gdsClient = new GlobalDiscoveryTestClient(true);
await _gdsClient.LoadClientConfiguration(_server.BasePort);
_pushClient = new ServerConfigurationPushTestClient(true);
await _pushClient.LoadClientConfiguration(_server.BasePort);
// connect once
await _gdsClient.GDSClient.Connect(_gdsClient.GDSClient.EndpointUrl);
await _pushClient.PushClient.Connect(_pushClient.PushClient.EndpointUrl);
ConnectGDSClient(true);
RegisterPushServerApplication(_pushClient.PushClient.EndpointUrl);
_selfSignedServerCert = new X509Certificate2(_pushClient.PushClient.Session.ConfiguredEndpoint.Description.ServerCertificate);
_domainNames = X509Utils.GetDomainsFromCertficate(_selfSignedServerCert).ToArray();
await CreateCATestCerts(_pushClient.TempStorePath);
}
public object Initialize(JToken arg)
{
var initialized = waitForInit?.WaitOne(30_000) ?? false;
if (!initialized)
{
return(new InitializeError {
Retry = true
});
}
var capabilities = new ServerCapabilities
{
TextDocumentSync = new TextDocumentSyncOptions
{
OpenClose = true,
Change = TextDocumentSyncKind.Full,
},
DocumentSymbolProvider = true,
CompletionProvider = new CompletionOptions
{
TriggerCharacters = new[] { ".", ",", "(" },
AllCommitCharacters = new[] { " ", ".", ",", "(", ")" }
},
};
waitForInit = null;
return(new InitializeResult {
Capabilities = capabilities
});
}
protected async Task OneTimeSetUp()
{
// make sure all servers started in travis use a different port, or test will fail
int testPort = 50000 + (((Int32)DateTime.UtcNow.ToFileTimeUtc() / 10000) & 0x1fff);
_serverCapabilities = new ServerCapabilities();
_randomSource = new RandomSource(randomStart);
_dataGenerator = new DataGenerator(_randomSource);
_server = new GlobalDiscoveryTestServer(true);
await _server.StartServer(true, testPort);
await Task.Delay(1000);
// load clients
_gdsClient = new GlobalDiscoveryTestClient(true);
await _gdsClient.LoadClientConfiguration(testPort);
_pushClient = new ServerConfigurationPushTestClient(true);
await _pushClient.LoadClientConfiguration(testPort);
// connect once
await _gdsClient.GDSClient.Connect(_gdsClient.GDSClient.EndpointUrl);
await _pushClient.PushClient.Connect(_pushClient.PushClient.EndpointUrl);
ConnectGDSClient(true);
RegisterPushServerApplication(_pushClient.PushClient.EndpointUrl);
_selfSignedServerCert = new X509Certificate2(_pushClient.PushClient.Session.ConfiguredEndpoint.Description.ServerCertificate);
_domainNames = Utils.GetDomainsFromCertficate(_selfSignedServerCert).ToArray();
CreateCATestCerts(_pushClient.TempStorePath);
}
public SessionSetupAndXRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
MaxBufferSize = LittleEndianConverter.ToUInt16(this.SMBParameters, 4);
MaxMpxCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 6);
VcNumber = LittleEndianConverter.ToUInt16(this.SMBParameters, 8);
SessionKey = LittleEndianConverter.ToUInt32(this.SMBParameters, 10);
OEMPasswordLength = LittleEndianConverter.ToUInt16(this.SMBParameters, 14);
UnicodePasswordLength = LittleEndianConverter.ToUInt16(this.SMBParameters, 16);
Reserved = LittleEndianConverter.ToUInt32(this.SMBParameters, 18);
Capabilities = (ServerCapabilities)LittleEndianConverter.ToUInt32(this.SMBParameters, 22);
OEMPassword = ByteReader.ReadBytes(this.SMBData, 0, OEMPasswordLength);
UnicodePassword = ByteReader.ReadBytes(this.SMBData, OEMPasswordLength, UnicodePasswordLength);
int dataOffset = OEMPasswordLength + UnicodePasswordLength;
if (isUnicode)
{
// A Unicode string MUST be aligned to a 16-bit boundary with respect to the beginning of the SMB Header.
// Note: SMBData starts at an odd offset.
int padding = (OEMPasswordLength + UnicodePasswordLength + 1) % 2;
dataOffset += padding;
}
AccountName = SMB1Helper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
PrimaryDomain = SMB1Helper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
NativeOS = SMB1Helper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
NativeLanMan = SMB1Helper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
}
protected void OneTimeSetUp()
{
#if DEBUG
// work around travis issue by selecting different ports on every run
const int testPort = 60000;
#else
const int testPort = 60010;
#endif
_serverCapabilities = new ServerCapabilities();
_randomSource = new RandomSource(randomStart);
_dataGenerator = new DataGenerator(_randomSource);
_server = new GlobalDiscoveryTestServer(true);
_server.StartServer(true, testPort).Wait();
// load client
_gdsClient = new GlobalDiscoveryTestClient(true);
_gdsClient.LoadClientConfiguration(testPort).Wait();
// good applications test set
_goodApplicationTestSet = ApplicationTestSet(goodApplicationsTestCount, false);
_invalidApplicationTestSet = ApplicationTestSet(invalidApplicationsTestCount, true);
_goodRegistrationOk = false;
_invalidRegistrationOk = false;
}
public string NativeLanMan; // SMB_STRING (this field WILL be aligned to start on a 2-byte boundary from the start of the SMB header)
public SessionSetupAndXRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
MaxBufferSize = LittleEndianConverter.ToUInt16(this.SMBParameters, 4);
MaxMpxCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 6);
VcNumber = LittleEndianConverter.ToUInt16(this.SMBParameters, 8);
SessionKey = LittleEndianConverter.ToUInt32(this.SMBParameters, 10);
ushort OEMPasswordLength = LittleEndianConverter.ToUInt16(this.SMBParameters, 14);
ushort UnicodePasswordLength = LittleEndianConverter.ToUInt16(this.SMBParameters, 16);
Reserved = LittleEndianConverter.ToUInt32(this.SMBParameters, 18);
Capabilities = (ServerCapabilities)LittleEndianConverter.ToUInt32(this.SMBParameters, 22);
OEMPassword = ByteReader.ReadBytes(this.SMBData, 0, OEMPasswordLength);
UnicodePassword = ByteReader.ReadBytes(this.SMBData, OEMPasswordLength, UnicodePasswordLength);
int dataOffset = OEMPasswordLength + UnicodePasswordLength;
if (isUnicode)
{
// wordCount is 1 byte
int padding = (1 + OEMPasswordLength + UnicodePasswordLength) % 2;
dataOffset += padding;
}
AccountName = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
PrimaryDomain = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
NativeOS = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
NativeLanMan = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
}
public override IHandlerResponse Handle(Map map, IContextRequest request)
{
ValidateParams(request, 0);
XmlDocument doc = ServerCapabilities.GetCapabilities(map, Description, request);
return(new GetCapabilitiesResponse(doc));
}
public void Null_Text_Document_Sync(string expected)
{
var model = new ServerCapabilities {
TextDocumentSync = new TextDocumentSync(new TextDocumentSyncOptions())
};
var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <ServerCapabilities>(expected);
deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality());
}
public object Initialize(JToken arg)
{
if (trace)
{
System.Console.Error.WriteLine("<-- Initialize");
System.Console.Error.WriteLine(arg.ToString());
}
var capabilities = new ServerCapabilities();
capabilities.TextDocumentSync = new TextDocumentSyncOptions();
capabilities.TextDocumentSync.OpenClose = true;
capabilities.TextDocumentSync.Change = TextDocumentSyncKind.Incremental;
capabilities.TextDocumentSync.Save = new SaveOptions();
capabilities.TextDocumentSync.Save.IncludeText = true;
capabilities.HoverProvider = true;
capabilities.CompletionProvider = new CompletionOptions();
capabilities.CompletionProvider.ResolveProvider = false;
capabilities.CompletionProvider.TriggerCharacters = new string[] { ",", "." };
capabilities.ReferencesProvider = false;
capabilities.DefinitionProvider = false;
capabilities.TypeDefinitionProvider = false; // Does not make sense for Antlr.
capabilities.ImplementationProvider = false; // Does not make sense for Antlr.
capabilities.DocumentHighlightProvider = false;
capabilities.DocumentSymbolProvider = false;
capabilities.WorkspaceSymbolProvider = false;
capabilities.DocumentFormattingProvider = false;
capabilities.DocumentRangeFormattingProvider = false;
capabilities.RenameProvider = false;
var result = new InitializeResult();
result.Capabilities = capabilities;
string json = JsonConvert.SerializeObject(result);
if (trace)
{
System.Console.Error.WriteLine("--> " + json);
}
return(result);
}
public void RegisterCapabilities(ServerCapabilities serverCapabilities)
{
foreach (var registrationOptions in LspHandlerDescriptorHelpers.GetStaticRegistrationOptions(
serverCapabilities
))
{
var method = _handlerTypeDescriptorProvider.GetMethodForRegistrationOptions(registrationOptions);
if (method == null)
{
_logger.LogWarning("Unable to find method for given {@RegistrationOptions}", registrationOptions);
continue;
}
if (string.IsNullOrWhiteSpace(registrationOptions.Id))
{
registrationOptions.Id = Guid.NewGuid().ToString();
}
var reg = new Registration {
Id = registrationOptions.Id,
Method = method,
RegisterOptions = registrationOptions
};
_registrations.AddOrUpdate(registrationOptions.Id, x => reg, (a, b) => reg);
}
if (serverCapabilities.Workspace == null)
{
_registrationSubject.OnNext(_registrations.Values);
return;
}
foreach (var registrationOptions in LspHandlerDescriptorHelpers.GetStaticRegistrationOptions(
serverCapabilities
.Workspace
))
{
var method = _handlerTypeDescriptorProvider.GetMethodForRegistrationOptions(registrationOptions);
if (method == null)
{
// TODO: Log this
continue;
}
var reg = new Registration {
Id = registrationOptions.Id,
Method = method,
RegisterOptions = registrationOptions
};
_registrations.AddOrUpdate(registrationOptions.Id, x => reg, (a, b) => reg);
}
}
protected override Result <InitializeResult, ResponseError <InitializeErrorData> > Initialize(InitializeParams parameters)
{
var capabilities = new ServerCapabilities
{
textDocumentSync = TextDocumentSyncKind.Incremental,
};
var result = new InitializeResult
{
capabilities = capabilities
};
return(Result <InitializeResult, ResponseError <InitializeErrorData> > .Success(result));
}
public void Optional(string expected)
{
var model = new ServerCapabilities {
ColorProvider = (ColorOptions)null
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <ServerCapabilities>(expected);
deresult.Should().BeEquivalentTo(model);
}
public void Optional(string expected)
{
var model = new ServerCapabilities {
ColorProvider = null
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <ServerCapabilities>(expected);
deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality());
}
public void Constructor_RegistrationExtensions_Populates()
{
// Arrange
var registrationExtension1 = new TestRegistrationExtension("test1");
var registrationExtension2 = new TestRegistrationExtension("test2");
var registrations = new IRegistrationExtension[] { registrationExtension1, registrationExtension2 };
var baseCapability = new ServerCapabilities();
// Act
var extendableCapabilities = new ExtendableServerCapabilities(baseCapability, registrations);
// Assert
Assert.Equal(new[] { "test1", "test2" }, extendableCapabilities.CapabilityExtensions.Keys.ToArray());
}
public ServerCapabilities GetCapabilities(ClientCapabilities clientCapabilities)
{
var capabilities = new ServerCapabilities();
if (clientCapabilities is VSClientCapabilities vsClientCapabilities && vsClientCapabilities.SupportsVisualStudioExtensions)
{
capabilities = GetVSServerCapabilities();
}
var commitCharacters = CompletionRules.Default.DefaultCommitCharacters.Select(c => c.ToString()).ToArray();
var triggerCharacters = _completionProviders.SelectMany(
lz => CompletionHandler.GetTriggerCharacters(lz.Value)).Distinct().Select(c => c.ToString()).ToArray();
capabilities.DefinitionProvider = true;
capabilities.RenameProvider = true;
capabilities.ImplementationProvider = true;
capabilities.CodeActionProvider = new CodeActionOptions {
CodeActionKinds = new[] { CodeActionKind.QuickFix, CodeActionKind.Refactor }
};
capabilities.CompletionProvider = new VisualStudio.LanguageServer.Protocol.CompletionOptions
{
ResolveProvider = true,
AllCommitCharacters = commitCharacters,
TriggerCharacters = triggerCharacters,
};
capabilities.SignatureHelpProvider = new SignatureHelpOptions {
TriggerCharacters = new[] { "(", "," }
};
capabilities.DocumentSymbolProvider = true;
capabilities.WorkspaceSymbolProvider = true;
capabilities.DocumentFormattingProvider = true;
capabilities.DocumentRangeFormattingProvider = true;
capabilities.DocumentOnTypeFormattingProvider = new DocumentOnTypeFormattingOptions {
FirstTriggerCharacter = "}", MoreTriggerCharacter = new[] { ";", "\n" }
};
capabilities.ReferencesProvider = true;
capabilities.FoldingRangeProvider = true;
capabilities.ExecuteCommandProvider = new ExecuteCommandOptions();
capabilities.TextDocumentSync = new TextDocumentSyncOptions
{
Change = TextDocumentSyncKind.Incremental,
OpenClose = true
};
capabilities.HoverProvider = true;
return(capabilities);
}
public SessionSetupRequest(byte[] buffer, int offset) : base(buffer, offset)
{
StructureSize = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 0);
Flags = (SessionSetupFlags)ByteReader.ReadByte(buffer, offset + SMB2Header.Length + 2);
SecurityMode = (SecurityMode)ByteReader.ReadByte(buffer, offset + SMB2Header.Length + 3);
Capabilities = (ServerCapabilities)LittleEndianConverter.ToUInt32(buffer, offset + SMB2Header.Length + 4);
Channel = LittleEndianConverter.ToUInt32(buffer, offset + SMB2Header.Length + 8);
SecurityBufferOffset = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 12);
SecurityBufferLength = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 14);
PreviousSessionId = LittleEndianConverter.ToUInt64(buffer, offset + SMB2Header.Length + 16);
if (SecurityBufferLength > 0)
{
SecurityBuffer = ByteReader.ReadBytes(buffer, offset + SecurityBufferOffset, SecurityBufferLength);
}
}
public void CapabilityExtensions_RoundTripsCorrectly()
{
// Arrange
var registrationExtension = new TestRegistrationExtension("test1");
var registrations = new IRegistrationExtension[] { registrationExtension };
var baseCapability = new ServerCapabilities();
var extendableCapabilities = new ExtendableServerCapabilities(baseCapability, registrations);
// Act
var serialized = JsonConvert.SerializeObject(extendableCapabilities);
var deserialized = JsonConvert.DeserializeObject <VSCapabilities>(serialized);
// Assert
Assert.True(deserialized.Test1);
}
/// <summary>
/// Retrieve the server's capabilities before additional requests are made to the remote host.
/// </summary>
/// <param name="cancellationToken"></param>
public void InitializeServerCapabilities(CancellationToken cancellationToken)
{
if (ActiveLanguageServerClient == null || ServerCapabilities != null)
{
return;
}
var initializeRequest = new LS.LspRequest <InitializeParams, InitializeResult>(Methods.InitializeName);
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
var intializeResult = await ActiveLanguageServerClient.RequestAsync(initializeRequest, new InitializeParams(), cancellationToken).ConfigureAwait(false);
ServerCapabilities = intializeResult?.Capabilities;
});
}
public NegotiateRequest(byte[] buffer, int offset) : base(buffer, offset)
{
StructureSize = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 0);
DialectCount = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 2);
SecurityMode = (SecurityMode)LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 4);
Reserved = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 6);
Capabilities = (ServerCapabilities)LittleEndianConverter.ToUInt32(buffer, offset + SMB2Header.Length + 8);
ClientGuid = LittleEndianConverter.ToGuid(buffer, offset + SMB2Header.Length + 12);
ClientStartTime = DateTime.FromFileTimeUtc(LittleEndianConverter.ToInt64(buffer, offset + SMB2Header.Length + 28));
for (int index = 0; index < DialectCount; index++)
{
SMB2Dialect dialect = (SMB2Dialect)LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 36 + index * 2);
Dialects.Add(dialect);
}
}
public void RegisterCapabilities(ServerCapabilities serverCapabilities)
{
foreach (var registrationOptions in LspHandlerDescriptorHelpers.GetStaticRegistrationOptions(serverCapabilities))
{
var method = _handlerTypeDescriptorProvider.GetMethodForRegistrationOptions(registrationOptions);
if (method == null)
{
_logger.LogWarning("Unable to find method for given {@RegistrationOptions}", registrationOptions);
continue;
}
if (registrationOptions.Id != null)
{
var reg = new Registration {
Id = registrationOptions.Id,
Method = method,
RegisterOptions = registrationOptions
};
_registrations.AddOrUpdate(registrationOptions.Id, _ => reg, (_, _) => reg);
}
}
if (serverCapabilities.Workspace != null)
{
foreach (var registrationOptions in LspHandlerDescriptorHelpers.GetStaticRegistrationOptions(serverCapabilities.Workspace))
{
var method = _handlerTypeDescriptorProvider.GetMethodForRegistrationOptions(registrationOptions);
if (method == null)
{
// TODO: Log this
continue;
}
if (registrationOptions.Id != null)
{
var reg = new Registration {
Id = registrationOptions.Id,
Method = method,
RegisterOptions = registrationOptions
};
_registrations.AddOrUpdate(registrationOptions.Id, _ => reg, (_, _) => reg);
}
}
}
_registrationSubject.OnNext(_registrations.Values);
}
public void RegisterCapabilities(ServerCapabilities serverCapabilities)
{
foreach (var registrationOptions in LspHandlerDescriptorHelpers.GetStaticRegistrationOptions(
serverCapabilities))
{
var descriptor = LspHandlerTypeDescriptorHelper.GetHandlerTypeForRegistrationOptions(registrationOptions);
if (descriptor == null)
{
_logger.LogWarning("Unable to find handler type descriptor for the given {@RegistrationOptions}", registrationOptions);
continue;
}
var reg = new Registration()
{
Id = registrationOptions.Id,
Method = descriptor.Method,
RegisterOptions = registrationOptions
};
_registrations.AddOrUpdate(registrationOptions.Id, (x) => reg, (a, b) => reg);
}
if (serverCapabilities.Workspace == null)
{
_registrationSubject.OnNext(_registrations.Values);
return;
}
foreach (var registrationOptions in LspHandlerDescriptorHelpers.GetStaticRegistrationOptions(serverCapabilities
.Workspace))
{
var descriptor = LspHandlerTypeDescriptorHelper.GetHandlerTypeForRegistrationOptions(registrationOptions);
if (descriptor == null)
{
// TODO: Log this
continue;
}
var reg = new Registration()
{
Id = registrationOptions.Id,
Method = descriptor.Method,
RegisterOptions = registrationOptions
};
_registrations.AddOrUpdate(registrationOptions.Id, (x) => reg, (a, b) => reg);
}
}
public void Resolve_Reference_ReturnsTrue()
{
// Arrange
var methodName = Methods.TextDocumentReferencesName;
var capabilities = new ServerCapabilities()
{
ReferencesProvider = true,
};
var jobjectCapabilities = JObject.FromObject(capabilities);
var filter = Resolver.Resolve(methodName);
// Act
var result = filter(jobjectCapabilities);
// Assert
Assert.True(result);
}
public void Resolve_TypeDefinitionOptions_ReturnsTrue()
{
// Arrange
var methodName = Methods.TextDocumentTypeDefinitionName;
var capabilities = new ServerCapabilities()
{
TypeDefinitionProvider = new TypeDefinitionOptions(),
};
var jobjectCapabilities = JObject.FromObject(capabilities);
var filter = Resolver.Resolve(methodName);
// Act
var result = filter(jobjectCapabilities);
// Assert
Assert.True(result);
}
public void Resolve_CodeLens_ReturnsTrue()
{
// Arrange
var methodName = Methods.CodeLensResolveName;
var capabilities = new ServerCapabilities()
{
CodeLensProvider = new CodeLensOptions(),
};
var jobjectCapabilities = JObject.FromObject(capabilities);
var filter = Resolver.Resolve(methodName);
// Act
var result = filter(jobjectCapabilities);
// Assert
Assert.True(result);
}
