public static void PredictInput()
{
const string Input = "Hello world";
MyPredictor slow = MyPredictor.SlowPredictor;
MyPredictor fast = MyPredictor.FastPredictor;
Ast ast = Parser.ParseInput(Input, out Token[] tokens, out _);
// Returns null when no predictor implementation registered
List <PredictionResult> results = CommandPrediction.PredictInput(Client, ast, tokens).Result;
Assert.Null(results);
try
{
// Register 2 predictor implementations
SubsystemManager.RegisterSubsystem <ICommandPredictor, MyPredictor>(slow);
SubsystemManager.RegisterSubsystem(SubsystemKind.CommandPredictor, fast);
// Expect the results from 'fast' predictor only b/c the 'slow' one
// cannot finish before the specified timeout.
// The specified timeout is exaggerated to make the test reliable.
// xUnit must spin up a lot tasks, which makes the test unreliable when the time difference between 'delay' and 'timeout' is small.
results = CommandPrediction.PredictInput(Client, ast, tokens, millisecondsTimeout: 1000).Result;
Assert.Single(results);
PredictionResult res = results[0];
Assert.Equal(fast.Id, res.Id);
Assert.Equal(Session, res.Session);
Assert.Equal(2, res.Suggestions.Count);
Assert.Equal($"'{Input}' from '{Client}' - TEST-1 from {fast.Name}", res.Suggestions[0].SuggestionText);
Assert.Equal($"'{Input}' from '{Client}' - TeSt-2 from {fast.Name}", res.Suggestions[1].SuggestionText);
// Expect the results from both 'slow' and 'fast' predictors
// Same here -- the specified timeout is exaggerated to make the test reliable.
// xUnit must spin up a lot tasks, which makes the test unreliable when the time difference between 'delay' and 'timeout' is small.
results = CommandPrediction.PredictInput(Client, ast, tokens, millisecondsTimeout: 4000).Result;
Assert.Equal(2, results.Count);
PredictionResult res1 = results[0];
Assert.Equal(slow.Id, res1.Id);
Assert.Equal(Session, res1.Session);
Assert.Equal(2, res1.Suggestions.Count);
Assert.Equal($"'{Input}' from '{Client}' - TEST-1 from {slow.Name}", res1.Suggestions[0].SuggestionText);
Assert.Equal($"'{Input}' from '{Client}' - TeSt-2 from {slow.Name}", res1.Suggestions[1].SuggestionText);
PredictionResult res2 = results[1];
Assert.Equal(fast.Id, res2.Id);
Assert.Equal(Session, res2.Session);
Assert.Equal(2, res2.Suggestions.Count);
Assert.Equal($"'{Input}' from '{Client}' - TEST-1 from {fast.Name}", res2.Suggestions[0].SuggestionText);
Assert.Equal($"'{Input}' from '{Client}' - TeSt-2 from {fast.Name}", res2.Suggestions[1].SuggestionText);
}
finally
{
SubsystemManager.UnregisterSubsystem <ICommandPredictor>(slow.Id);
SubsystemManager.UnregisterSubsystem(SubsystemKind.CommandPredictor, fast.Id);
}
}
/// <inheritdoc/>
public void OnImport()
{
var settings = Settings.GetSettings();
var azContext = new AzContext();
azContext.UpdateContext();
var telemetryClient = new AzPredictorTelemetryClient(azContext);
var azPredictorService = new AzPredictorService(settings.ServiceUri, telemetryClient, azContext);
var predictor = new AzPredictor(azPredictorService, telemetryClient, settings, azContext);
SubsystemManager.RegisterSubsystem <ICommandPredictor, AzPredictor>(predictor);
}
public static void Feedback()
{
MyPredictor slow = MyPredictor.SlowPredictor;
MyPredictor fast = MyPredictor.FastPredictor;
try
{
// Register 2 predictor implementations
SubsystemManager.RegisterSubsystem <ICommandPredictor, MyPredictor>(slow);
SubsystemManager.RegisterSubsystem(SubsystemKind.CommandPredictor, fast);
var history = new[] { "hello", "world" };
var ids = new HashSet <Guid> {
slow.Id, fast.Id
};
CommandPrediction.OnCommandLineAccepted(Client, history);
CommandPrediction.OnSuggestionDisplayed(Client, slow.Id, Session, 2);
CommandPrediction.OnSuggestionDisplayed(Client, fast.Id, Session, -1);
CommandPrediction.OnSuggestionAccepted(Client, slow.Id, Session, "Yeah");
// The calls to 'StartEarlyProcessing' and 'OnSuggestionAccepted' are queued in thread pool,
// so we wait a bit to make sure the calls are done.
while (slow.History.Count == 0 || slow.AcceptedSuggestions.Count == 0)
{
Thread.Sleep(10);
}
Assert.Equal(2, slow.History.Count);
Assert.Equal($"{Client}-{history[0]}", slow.History[0]);
Assert.Equal($"{Client}-{history[1]}", slow.History[1]);
Assert.Equal(2, fast.History.Count);
Assert.Equal($"{Client}-{history[0]}", fast.History[0]);
Assert.Equal($"{Client}-{history[1]}", fast.History[1]);
Assert.Single(slow.DisplayedSuggestions);
Assert.Equal($"{Client}-{Session}-2", slow.DisplayedSuggestions[0]);
Assert.Single(fast.DisplayedSuggestions);
Assert.Equal($"{Client}-{Session}--1", fast.DisplayedSuggestions[0]);
Assert.Single(slow.AcceptedSuggestions);
Assert.Equal($"{Client}-{Session}-Yeah", slow.AcceptedSuggestions[0]);
Assert.Empty(fast.AcceptedSuggestions);
}
finally
{
SubsystemManager.UnregisterSubsystem <ICommandPredictor>(slow.Id);
SubsystemManager.UnregisterSubsystem(SubsystemKind.CommandPredictor, fast.Id);
}
}
public static void UnregisterSubsystem()
{
// Exception expected when no implementation is registered
Assert.Throws <InvalidOperationException>(() => SubsystemManager.UnregisterSubsystem <ICommandPredictor>(predictor1.Id));
SubsystemManager.RegisterSubsystem <ICommandPredictor, MyPredictor>(predictor1);
SubsystemManager.RegisterSubsystem(SubsystemKind.CommandPredictor, predictor2);
// Exception is expected when specified id cannot be found
Assert.Throws <InvalidOperationException>(() => SubsystemManager.UnregisterSubsystem <ICommandPredictor>(Guid.NewGuid()));
// Unregister 'predictor1'
SubsystemManager.UnregisterSubsystem <ICommandPredictor>(predictor1.Id);
SubsystemInfo ssInfo = SubsystemManager.GetSubsystemInfo(SubsystemKind.CommandPredictor);
VerifyCommandPredictorMetadata(ssInfo);
Assert.True(ssInfo.IsRegistered);
Assert.Single(ssInfo.Implementations);
var implInfo = ssInfo.Implementations[0];
Assert.Equal(predictor2.Id, implInfo.Id);
Assert.Equal(predictor2.Name, implInfo.Name);
Assert.Equal(predictor2.Description, implInfo.Description);
Assert.Equal(SubsystemKind.CommandPredictor, implInfo.Kind);
Assert.Same(typeof(MyPredictor), implInfo.ImplementationType);
ICommandPredictor impl = SubsystemManager.GetSubsystem <ICommandPredictor>();
Assert.Same(impl, predictor2);
ReadOnlyCollection <ICommandPredictor> impls = SubsystemManager.GetSubsystems <ICommandPredictor>();
Assert.Single(impls);
Assert.Same(predictor2, impls[0]);
// Unregister 'predictor2'
SubsystemManager.UnregisterSubsystem(SubsystemKind.CommandPredictor, predictor2.Id);
VerifyCommandPredictorMetadata(ssInfo);
Assert.False(ssInfo.IsRegistered);
Assert.Empty(ssInfo.Implementations);
impl = SubsystemManager.GetSubsystem <ICommandPredictor>();
Assert.Null(impl);
impls = SubsystemManager.GetSubsystems <ICommandPredictor>();
Assert.Empty(impls);
}
/// <inheritdoc/>
public void OnImport()
{
var settings = Settings.GetSettings();
var azContext = new AzContext()
{
IsInternal = (settings.SetAsInternal == true) ? true : false,
SurveyId = settings.SurveyId?.ToString(CultureInfo.InvariantCulture) ?? string.Empty,
};
azContext.UpdateContext();
var telemetryClient = new AzPredictorTelemetryClient(azContext);
var azPredictorService = new AzPredictorService(settings.ServiceUri, telemetryClient, azContext);
var predictor = new AzPredictor(azPredictorService, telemetryClient, settings, azContext);
SubsystemManager.RegisterSubsystem <ICommandPredictor, AzPredictor>(predictor);
}
/// <inheritdoc/>
public void OnImport()
{
var predictor = new AzPredictor();
SubsystemManager.RegisterSubsystem <ICommandPredictor, AzPredictor>(predictor);
}
public static void RegisterSubsystem()
{
try
{
Assert.Throws <ArgumentNullException>(
paramName: "proxy",
() => SubsystemManager.RegisterSubsystem <ICommandPredictor, MyPredictor>(null));
Assert.Throws <ArgumentNullException>(
paramName: "proxy",
() => SubsystemManager.RegisterSubsystem(SubsystemKind.CommandPredictor, null));
Assert.Throws <ArgumentException>(
paramName: "proxy",
() => SubsystemManager.RegisterSubsystem((SubsystemKind)0, predictor1));
// Register 'predictor1'
SubsystemManager.RegisterSubsystem <ICommandPredictor, MyPredictor>(predictor1);
// Now validate the SubsystemInfo of the 'ICommandPredictor' subsystem
SubsystemInfo ssInfo = SubsystemManager.GetSubsystemInfo(typeof(ICommandPredictor));
SubsystemInfo crossPlatformDscInfo = SubsystemManager.GetSubsystemInfo(typeof(ICrossPlatformDsc));
VerifyCommandPredictorMetadata(ssInfo);
Assert.True(ssInfo.IsRegistered);
Assert.Single(ssInfo.Implementations);
// Now validate the 'ImplementationInfo'
var implInfo = ssInfo.Implementations[0];
Assert.Equal(predictor1.Id, implInfo.Id);
Assert.Equal(predictor1.Name, implInfo.Name);
Assert.Equal(predictor1.Description, implInfo.Description);
Assert.Equal(SubsystemKind.CommandPredictor, implInfo.Kind);
Assert.Same(typeof(MyPredictor), implInfo.ImplementationType);
// Now validate the subsystem implementation itself.
ICommandPredictor impl = SubsystemManager.GetSubsystem <ICommandPredictor>();
Assert.Same(impl, predictor1);
Assert.Null(impl.FunctionsToDefine);
Assert.Equal(SubsystemKind.CommandPredictor, impl.Kind);
const string Client = "SubsystemTest";
const string Input = "Hello world";
var predClient = new PredictionClient(Client, PredictionClientKind.Terminal);
var predCxt = PredictionContext.Create(Input);
var results = impl.GetSuggestion(predClient, predCxt, CancellationToken.None);
Assert.Equal($"'{Input}' from '{Client}' - TEST-1 from {impl.Name}", results.SuggestionEntries[0].SuggestionText);
Assert.Equal($"'{Input}' from '{Client}' - TeSt-2 from {impl.Name}", results.SuggestionEntries[1].SuggestionText);
// Now validate the all-subsystem-implementation collection.
ReadOnlyCollection <ICommandPredictor> impls = SubsystemManager.GetSubsystems <ICommandPredictor>();
Assert.Single(impls);
Assert.Same(predictor1, impls[0]);
// Register 'predictor2'
SubsystemManager.RegisterSubsystem(SubsystemKind.CommandPredictor, predictor2);
// Now validate the SubsystemInfo of the 'ICommandPredictor' subsystem
VerifyCommandPredictorMetadata(ssInfo);
Assert.True(ssInfo.IsRegistered);
Assert.Equal(2, ssInfo.Implementations.Count);
// Now validate the new 'ImplementationInfo'
implInfo = ssInfo.Implementations[1];
Assert.Equal(predictor2.Id, implInfo.Id);
Assert.Equal(predictor2.Name, implInfo.Name);
Assert.Equal(predictor2.Description, implInfo.Description);
Assert.Equal(SubsystemKind.CommandPredictor, implInfo.Kind);
Assert.Same(typeof(MyPredictor), implInfo.ImplementationType);
// Now validate the new subsystem implementation.
impl = SubsystemManager.GetSubsystem <ICommandPredictor>();
Assert.Same(impl, predictor2);
// Now validate the all-subsystem-implementation collection.
impls = SubsystemManager.GetSubsystems <ICommandPredictor>();
Assert.Equal(2, impls.Count);
Assert.Same(predictor1, impls[0]);
Assert.Same(predictor2, impls[1]);
}
finally
{
SubsystemManager.UnregisterSubsystem <ICommandPredictor>(predictor1.Id);
SubsystemManager.UnregisterSubsystem(SubsystemKind.CommandPredictor, predictor2.Id);
}
}