public async Task TestSearchPackageMultipleNames()
{
var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict);
installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true);
installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false);
installerServiceMock.Setup(i => i.GetInstalledVersions("NuGetPackage")).Returns(ImmutableArray <string> .Empty);
installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources);
installerServiceMock.Setup(s => s.TryInstallPackage(It.IsAny <Workspace>(), It.IsAny <DocumentId>(), It.IsAny <string>(), "NuGetPackage", It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(true);
var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict);
packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty));
packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync(
NugetOrgSource, "NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NS1", "NS2")));
await TestInRegularAndScriptAsync(
@"class C
{
[|NuGetType|] n;
}",
@"using NS1.NS2;
class C
{
NuGetType n;
}", fixProviderData : new FixProviderData(installerServiceMock.Object, packageServiceMock.Object));
}
public async Task TestSearchPackageFakeNugetFeed()
{
var packageSources = ImmutableArray.Create(new PackageSource("nuget.org", "http://fakenuget.org/"));
var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict);
installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true);
installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false);
installerServiceMock.Setup(i => i.GetInstalledVersions("NuGetPackage")).Returns(ImmutableArray <string> .Empty);
installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(packageSources);
installerServiceMock.Setup(s => s.TryInstallPackageAsync(It.IsAny <Workspace>(), It.IsAny <DocumentId>(), It.IsAny <string>(), "NuGetPackage", It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <IProgressTracker>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(true));
var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict);
packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty));
packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync(
"nuget.org", "NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NuGetNamespace")));
await TestInRegularAndScriptAsync(
@"class C
{
[|NuGetType|] n;
}",
@"using NuGetNamespace;
class C
{
NuGetType n;
}", fixProviderData : new FixProviderData(installerServiceMock.Object, packageServiceMock.Object));
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var type = message.GetType();
var jsonString = JsonConvert.SerializeObject(message, type, Settings);
messageHeaders.AddOrReplace(DefaultMessageHeaders.MessageType, type.AssemblyQualifiedName);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(GetSystemEncoding().GetBytes(jsonString))));
}
public void FromException_WithIntResult_FaultedTaskCreated()
{
var result = ValueTaskFactory.FromException <int>(new ArgumentNullException());
result.IsCompleted.Should().BeTrue();
result.IsFaulted.Should().BeTrue();
}
private ValueTask <ImmutableArray <DiagnosticData> > DeserializeDiagnosticsAsync(
IPersistentStorageService persistentService,
DiagnosticDataSerializer serializer,
Project project,
TextDocument?document,
object key,
string stateKey,
CancellationToken cancellationToken
)
{
Contract.ThrowIfFalse(document == null || document.Project == project);
if (
InMemoryStorage.TryGetValue(_owner.Analyzer, (key, stateKey), out var entry) &&
serializer.Version == entry.Version
)
{
return(ValueTaskFactory.FromResult(entry.Diagnostics));
}
return(serializer.DeserializeAsync(
persistentService,
project,
document,
stateKey,
cancellationToken
));
}
public ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var binaryFileMessage = message as IBinaryFileMessage;
if (binaryFileMessage == null)
{
throw new ArgumentException(
"The message is not implementing the IBinaryFileMessage interface.",
nameof(message));
}
return(ValueTaskFactory.FromResult(binaryFileMessage.Content));
}
public ValueTask <T?> GetProxyAsync <T>(ServiceRpcDescriptor descriptor, ServiceActivationOptions options, CancellationToken cancellationToken) where T : class
{
var pipePair = FullDuplexStream.CreatePipePair();
var clientConnection = descriptor
.WithTraceSource(_services.ServiceProvider.TraceSource)
.ConstructRpcConnection(pipePair.Item2);
Contract.ThrowIfFalse(options.ClientRpcTarget is null == descriptor.ClientInterface is null);
if (descriptor.ClientInterface != null)
{
Contract.ThrowIfNull(options.ClientRpcTarget);
clientConnection.AddLocalRpcTarget(options.ClientRpcTarget);
}
// Clear RPC target so that the server connection is forced to create a new proxy for the callback
// instead of just invoking the callback object directly (this emulates the product that does
// not serialize the callback object over).
options.ClientRpcTarget = null;
// Creates service instance and connects it to the pipe.
// We don't need to store the instance anywhere.
_ = _services.CreateBrokeredService(descriptor, pipePair.Item1, options);
clientConnection.StartListening();
return(ValueTaskFactory.FromResult((T?)clientConnection.ConstructRpcClient <T>()));
}
/// <nodoc/>
public ValueTask <Possible <ModuleDefinition> > TryGetModuleDefinitionAsync(ModuleDescriptor moduleDescriptor)
{
return(ValueTaskFactory.FromResult(m_moduleDefinitions.ContainsKey(moduleDescriptor)
? new Possible <ModuleDefinition>(m_moduleDefinitions[moduleDescriptor])
: new Possible <ModuleDefinition>(
new ModuleNotFoundInSimpleSourceResolverFailure(moduleDescriptor))));
}
public async Task TestFailedInstallRollsBackFile()
{
var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict);
installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true);
installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false);
installerServiceMock.Setup(i => i.GetProjectsWithInstalledPackage(It.IsAny <Solution>(), "NuGetPackage", "1.0")).Returns(ImmutableArray <Project> .Empty);
installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources);
installerServiceMock.Setup(s => s.GetInstalledVersions("NuGetPackage"))
.Returns(ImmutableArray.Create("1.0"));
installerServiceMock.Setup(s => s.TryInstallPackageAsync(It.IsAny <Workspace>(), It.IsAny <DocumentId>(), It.IsAny <string>(), "NuGetPackage", "1.0", It.IsAny <bool>(), It.IsAny <IProgressTracker>(), It.IsAny <CancellationToken>()))
.Returns(SpecializedTasks.False);
var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict);
packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty));
packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync(PackageSourceHelper.NugetOrgSourceName, "NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NuGetNamespace")));
await TestInRegularAndScriptAsync(
@"class C
{
[|NuGetType|] n;
}",
@"class C
{
NuGetType n;
}", fixProviderData : new FixProviderData(installerServiceMock.Object, packageServiceMock.Object));
installerServiceMock.Verify();
}
public ValueTask <ImmutableArray <(Checksum, object)> > GetAssetsAsync(
int serviceId, ISet <Checksum> checksums, ISerializerService deserializerService, CancellationToken cancellationToken)
{
var results = new List <(Checksum, object)>();
foreach (var checksum in checksums)
{
if (_map.TryGetValue(checksum, out var data))
{
using var stream = new MemoryStream();
using (var writer = new ObjectWriter(stream, leaveOpen: true, cancellationToken))
{
_serializerService.Serialize(data, writer, cancellationToken);
}
stream.Position = 0;
using var reader = ObjectReader.GetReader(stream, leaveOpen: true, cancellationToken);
var asset = deserializerService.Deserialize <object>(data.GetWellKnownSynchronizationKind(), reader, cancellationToken);
Contract.ThrowIfTrue(asset is null);
results.Add((checksum, asset));
}
else
{
throw ExceptionUtilities.UnexpectedValue(checksum);
}
}
return(ValueTaskFactory.FromResult(results.ToImmutableArray()));
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var type = message.GetType();
messageHeaders.AddOrReplace(DefaultMessageHeaders.MessageType, type.AssemblyQualifiedName);
var bytes = JsonSerializer.SerializeToUtf8Bytes(message, type, Options);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(bytes)));
}
public static ValueTask <ImmutableArray <ISymbol> > FindBasesAsync(
ISymbol symbol,
Solution solution,
CancellationToken cancellationToken
)
{
if (
symbol is INamedTypeSymbol namedTypeSymbol &&
(
namedTypeSymbol.TypeKind == TypeKind.Class ||
namedTypeSymbol.TypeKind == TypeKind.Interface ||
namedTypeSymbol.TypeKind == TypeKind.Struct
)
)
{
return(ValueTaskFactory.FromResult(
BaseTypeFinder.FindBaseTypesAndInterfaces(namedTypeSymbol)
));
}
if (
symbol.Kind == SymbolKind.Property ||
symbol.Kind == SymbolKind.Method ||
symbol.Kind == SymbolKind.Event
)
{
return(BaseTypeFinder.FindOverriddenAndImplementedMembersAsync(
symbol,
solution,
cancellationToken
));
}
return(ValueTaskFactory.FromResult(ImmutableArray <ISymbol> .Empty));
}
private async Task <RemoteHostClient?> CreateHostClientAsync()
{
try
{
var brokeredServiceContainer = await _vsServiceProvider
.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>()
.ConfigureAwait(false);
var serviceBroker = brokeredServiceContainer.GetFullAccessServiceBroker();
// VS AsyncLazy does not currently support cancellation:
var client = await ServiceHubRemoteHostClient
.CreateAsync(
_services,
_listenerProvider,
serviceBroker,
_callbackDispatchers,
CancellationToken.None
)
.ConfigureAwait(false);
// proffer in-proc brokered services:
_ = brokeredServiceContainer.Proffer(
SolutionAssetProvider.ServiceDescriptor,
(_, _, _, _) =>
ValueTaskFactory.FromResult <object?>(new SolutionAssetProvider(_services))
);
return(client);
}
catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e))
{
return(null);
}
}
/// <nodoc/>
public ValueTask <Possible <IReadOnlyCollection <ModuleDescriptor> > > TryGetModuleDescriptorsAsync(ModuleReferenceWithProvenance moduleReference)
{
return
(ValueTaskFactory.FromResult(
new Possible <IReadOnlyCollection <ModuleDescriptor> >(
m_moduleDefinitions.Keys.Where(moduleDescriptor => moduleDescriptor.Name.Equals(moduleReference.Name))
.ToList())));
}
public void FromResult_IntResult_SuccessfulTaskCreated()
{
var result = ValueTaskFactory.FromResult(42);
result.IsCompleted.Should().BeTrue();
result.IsCompletedSuccessfully.Should().BeTrue();
result.Result.Should().Be(42);
}
ValueTask <CodeAndImportGenerationOptions> OptionsProvider <CodeAndImportGenerationOptions> .GetOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken)
{
var codeActionOptions = GetOptions(languageServices);
return(ValueTaskFactory.FromResult(new CodeAndImportGenerationOptions(
codeActionOptions.CodeGenerationOptions ?? CodeGenerationOptions.GetDefault(languageServices),
codeActionOptions.CleanupOptions?.AddImportOptions ?? AddImportPlacementOptions.Default)));
}
public void WhenAll_AllCompletedSuccessfully()
{
var whenAll = SpecializedTasks.WhenAll(new[] { ValueTaskFactory.FromResult(0), ValueTaskFactory.FromResult(1) });
Debug.Assert(whenAll.IsCompleted);
Assert.True(whenAll.IsCompletedSuccessfully);
Assert.Equal(new[] { 0, 1 }, whenAll.Result);
}
public static ValueTask <OptionSet?> GetDocumentOptionSetAsync(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken)
{
if (analyzerOptions is not WorkspaceAnalyzerOptions workspaceAnalyzerOptions)
{
return(ValueTaskFactory.FromResult((OptionSet?)null));
}
return(workspaceAnalyzerOptions.GetDocumentOptionSetAsync(syntaxTree, cancellationToken));
}
public void FromCanceled_WithIntResult_CanceledTaskCreated()
{
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
var result = ValueTaskFactory.FromCanceled <int>(cancellationTokenSource.Token);
result.IsCompleted.Should().BeTrue();
result.IsCanceled.Should().BeTrue();
}
private static ValueTask <ImmutableArray <INavigateToSearchResult> > RehydrateAsync(
Optional <ImmutableArray <SerializableNavigateToSearchResult> > result,
Solution solution,
CancellationToken cancellationToken)
{
if (result.HasValue)
{
return(result.Value.SelectAsArrayAsync(r => r.RehydrateAsync(solution, cancellationToken)));
}
else
{
return(ValueTaskFactory.FromResult(ImmutableArray <INavigateToSearchResult> .Empty));
}
}
public async ValueTask <Solution> GetSolutionAsync(ServiceBrokerClient client, Checksum solutionChecksum, CancellationToken cancellationToken)
{
var assetSource = new SolutionAssetSource(client);
var workspace = GetWorkspace();
var assetProvider = workspace.CreateAssetProvider(solutionChecksum, SolutionAssetCache, assetSource);
var(solution, _) = await workspace.RunWithSolutionAsync(
assetProvider,
solutionChecksum,
static _ => ValueTaskFactory.FromResult(false),
cancellationToken).ConfigureAwait(false);
return(solution);
}
/// <nodoc/>
public ValueTask <Possible <ModuleDescriptor> > TryGetOwningModuleDescriptorAsync(AbsolutePath specPath)
{
foreach (var moduleDefinition in m_moduleDefinitions.Values)
{
if (moduleDefinition.Specs.Contains(specPath))
{
return(ValueTaskFactory.FromResult(new Possible <ModuleDescriptor>(moduleDefinition.Descriptor)));
}
}
return
(ValueTaskFactory.FromResult(
new Possible <ModuleDescriptor>(new ModuleNotFoundInSimpleSourceResolverFailure(specPath))));
}
public ValueTask <ManagedHotReloadAvailability> GetAvailabilityAsync(Guid mvid, CancellationToken cancellationToken)
{
if (IsEditAndContinueAvailable != null)
{
return(ValueTaskFactory.FromResult(IsEditAndContinueAvailable(mvid)));
}
if (LoadedModules != null)
{
return(ValueTaskFactory.FromResult(LoadedModules.TryGetValue(mvid, out var result) ? result : new ManagedHotReloadAvailability(ManagedHotReloadAvailabilityStatus.ModuleNotLoaded)));
}
throw new NotImplementedException();
}
public async Task TestOptionsOffered()
{
var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict);
installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true);
installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false);
installerServiceMock.Setup(i => i.GetProjectsWithInstalledPackage(It.IsAny <Solution>(), "NuGetPackage", "1.0")).Returns(ImmutableArray <Project> .Empty);
installerServiceMock.Setup(i => i.GetProjectsWithInstalledPackage(It.IsAny <Solution>(), "NuGetPackage", "2.0")).Returns(ImmutableArray <Project> .Empty);
installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources);
installerServiceMock.Setup(s => s.GetInstalledVersions("NuGetPackage"))
.Returns(ImmutableArray.Create("1.0", "2.0"));
var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict);
packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty));
packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync(
PackageSourceHelper.NugetOrgSourceName, "NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NS1", "NS2")));
var data = new FixProviderData(installerServiceMock.Object, packageServiceMock.Object);
await TestSmartTagTextAsync(
@"class C
{
[|NuGetType|] n;
}",
string.Format(FeaturesResources.Use_local_version_0, "1.0"),
parameters : new TestParameters(fixProviderData: data));
await TestSmartTagTextAsync(
@"class C
{
[|NuGetType|] n;
}",
string.Format(FeaturesResources.Use_local_version_0, "2.0"),
parameters : new TestParameters(index: 1, fixProviderData: data));
await TestSmartTagTextAsync(
@"class C
{
[|NuGetType|] n;
}",
FeaturesResources.Find_and_install_latest_version,
parameters : new TestParameters(index: 2, fixProviderData: data));
}
public async Task TestMissingIfPackageAlreadyInstalled()
{
var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict);
installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true);
installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources);
installerServiceMock.Setup(s => s.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage"))
.Returns(true);
var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict);
packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty));
packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync(
PackageSourceHelper.NugetOrgSourceName, "NuGetType", 0, It.IsAny <CancellationToken>()))
.Returns(() => CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NS1", "NS2")));
await TestMissingInRegularAndScriptAsync(
@"class C
{
[|NuGetType|] n;
}", new TestParameters(fixProviderData : new FixProviderData(installerServiceMock.Object, packageServiceMock.Object)));
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var bytes = JsonSerializer.SerializeToUtf8Bytes(message, _type, Options);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(bytes)));
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var jsonString = JsonConvert.SerializeObject(message, _type, Settings);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(GetSystemEncoding().GetBytes(jsonString))));
}
public ValueTask <bool> IsExperimentEnabledAsync(string experimentName, CancellationToken cancellationToken) => ValueTaskFactory.FromResult(false);
protected override ValueTask <ImmutableArray <Document> > GetOrderedDocumentsAsync(RequestContext context, CancellationToken cancellationToken)
{
return(ValueTaskFactory.FromResult(GetRequestedDocument(context)));
}
public static ValueTask <ISymbolSearchUpdateEngine> CreateEngineAsync(
Workspace workspace,
ISymbolSearchLogService logService,
CancellationToken cancellationToken)
=> ValueTaskFactory.FromResult <ISymbolSearchUpdateEngine>(SymbolSearchUpdateNoOpEngine.Instance);
