[Settings]New Landing Page Experimentation (#22365)

Co-authored-by: Sophia Chen <sophia.six.chen@gmail.com>
Co-authored-by: Niels Laute <niels.laute@live.nl>
Co-authored-by: Sophia Chen <sophchen@microsoft.com>

src/common/AllExperiments/AllExperiments.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\..\Version.props" />
+  <PropertyGroup>
+    <TargetFramework>net7.0-windows10.0.19041.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <TargetName>PowerToys.AllExperiments</TargetName>
+    <MockDirectory>.\Microsoft.VariantAssignment\</MockDirectory>
+  </PropertyGroup>
+
+  
+  <ItemGroup>
+    <ProjectReference Include="..\ManagedTelemetry\Telemetry\ManagedTelemetry.csproj" />
+    <ProjectReference Include="..\..\settings-ui\Settings.UI.Library\Settings.UI.Library.csproj" />
+  </ItemGroup>
+
+  <!-- Experimentation is live, forcing inclusion -->
+  <ItemGroup Condition="'$(IsExperimentationLive)'!=''">
+    <!-- Newtonsoft.Json is included and a version specified in Directory.Packages.props to avoid a vulnerability from older versions. -->
+    <PackageReference Include="Newtonsoft.Json" />
+    <PackageReference Include="Microsoft.VariantAssignment.Client" />
+    <PackageReference Include="Microsoft.VariantAssignment.Contract" />
+    <Compile Remove=".\$(MockDirectory)\Client\*.cs" />
+    <Compile Remove=".\$(MockDirectory)\Contract\*.cs" />
+  </ItemGroup>
+
+</Project>

src/common/AllExperiments/Experiments.cs

@@ -0,0 +1,211 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+using Microsoft.PowerToys.Settings.UI.Library.Telemetry.Events;
+using Microsoft.PowerToys.Telemetry;
+using Microsoft.VariantAssignment.Client;
+using Microsoft.VariantAssignment.Contract;
+using Windows.System.Profile;
+
+namespace AllExperiments
+{
+// The dependencies required to build this project are only available in the official build pipeline and are internal to Microsoft.
+// However, this project is not required to build a test version of the application.
+    public class Experiments
+   {
+        public enum ExperimentState
+        {
+            Enabled,
+            Disabled,
+            NotLoaded,
+        }
+
+#pragma warning disable SA1401 // Need to use LandingPageExperiment as a static property in OobeShellPage.xaml.cs
+        public static ExperimentState LandingPageExperiment = ExperimentState.NotLoaded;
+#pragma warning restore SA1401
+
+        public async Task<bool> EnableLandingPageExperimentAsync()
+        {
+            if (Experiments.LandingPageExperiment != ExperimentState.NotLoaded)
+            {
+                return Experiments.LandingPageExperiment == ExperimentState.Enabled;
+            }
+
+            Experiments varServ = new Experiments();
+            await varServ.VariantAssignmentProvider_Initialize();
+            var landingPageExperiment = varServ.IsExperiment;
+
+            Experiments.LandingPageExperiment = landingPageExperiment ? ExperimentState.Enabled : ExperimentState.Disabled;
+
+            return landingPageExperiment;
+        }
+
+        private async Task VariantAssignmentProvider_Initialize()
+        {
+            IsExperiment = false;
+            string jsonFilePath = CreateFilePath();
+
+            var vaSettings = new VariantAssignmentClientSettings
+            {
+                Endpoint = new Uri("https://default.exp-tas.com/exptas77/a7a397e7-6fbe-4f21-a4e9-3f542e4b000e-exppowertoys/api/v1/tas"),
+                EnableCaching = true,
+                ResponseCacheTime = TimeSpan.FromMinutes(5),
+            };
+
+            try
+            {
+                var vaClient = vaSettings.GetTreatmentAssignmentServiceClient();
+                var vaRequest = GetVariantAssignmentRequest();
+                using var variantAssignments = await vaClient.GetVariantAssignmentsAsync(vaRequest).ConfigureAwait(false);
+
+                if (variantAssignments.AssignedVariants.Count != 0)
+                {
+                    var dataVersion = variantAssignments.DataVersion;
+                    var featureVariables = variantAssignments.GetFeatureVariables();
+                    var assignmentContext = variantAssignments.GetAssignmentContext();
+                    var featureFlagValue = featureVariables[0].GetStringValue();
+
+                    var experimentGroup = string.Empty;
+                    string json = File.ReadAllText(jsonFilePath);
+                    var jsonDictionary = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
+
+                    if (jsonDictionary != null)
+                    {
+                        if (!jsonDictionary.ContainsKey("dataversion"))
+                        {
+                            jsonDictionary.Add("dataversion", dataVersion);
+                        }
+
+                        if (!jsonDictionary.ContainsKey("variantassignment"))
+                        {
+                            jsonDictionary.Add("variantassignment", featureFlagValue);
+                        }
+                        else
+                        {
+                            var jsonDataVersion = jsonDictionary["dataversion"].ToString();
+                            if (jsonDataVersion != null && int.Parse(jsonDataVersion) < dataVersion)
+                            {
+                                jsonDictionary["dataversion"] = dataVersion;
+                                jsonDictionary["variantassignment"] = featureFlagValue;
+                            }
+                        }
+
+                        experimentGroup = jsonDictionary["variantassignment"].ToString();
+
+                        string output = JsonSerializer.Serialize(jsonDictionary);
+                        File.WriteAllText(jsonFilePath, output);
+                    }
+
+                    if (experimentGroup == "alternate" && AssignmentUnit != string.Empty)
+                    {
+                        IsExperiment = true;
+                    }
+
+                    PowerToysTelemetry.Log.WriteEvent(new OobeVariantAssignmentEvent() { AssignmentContext = assignmentContext, ClientID = AssignmentUnit });
+                }
+            }
+            catch (HttpRequestException ex)
+            {
+                string json = File.ReadAllText(jsonFilePath);
+                var jsonDictionary = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
+
+                if (jsonDictionary != null)
+                {
+                    if (jsonDictionary.ContainsKey("variantassignment"))
+                    {
+                        if (jsonDictionary["variantassignment"].ToString() == "alternate" && AssignmentUnit != string.Empty)
+                        {
+                            IsExperiment = true;
+                        }
+                    }
+                    else
+                    {
+                        jsonDictionary["variantassignment"] = "current";
+                    }
+                }
+
+                string output = JsonSerializer.Serialize(jsonDictionary);
+                File.WriteAllText(jsonFilePath, output);
+
+                Logger.LogError("Error getting to TAS endpoint", ex);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError("Error getting variant assignments for experiment", ex);
+            }
+        }
+
+        public bool IsExperiment { get; set; }
+
+        private string? AssignmentUnit { get; set; }
+
+        private IVariantAssignmentRequest GetVariantAssignmentRequest()
+        {
+            var jsonFilePath = CreateFilePath();
+            try
+            {
+                if (!File.Exists(jsonFilePath))
+                {
+                    AssignmentUnit = Guid.NewGuid().ToString();
+                    var data = new Dictionary<string, string>()
+                    {
+                        ["clientid"] = AssignmentUnit,
+                    };
+                    string jsonData = JsonSerializer.Serialize(data);
+                    File.WriteAllText(jsonFilePath, jsonData);
+                }
+                else
+                {
+                    string json = File.ReadAllText(jsonFilePath);
+                    var jsonDictionary = System.Text.Json.JsonSerializer.Deserialize<Dictionary<string, object>>(json);
+                    if (jsonDictionary != null)
+                    {
+                        AssignmentUnit = jsonDictionary["clientid"]?.ToString();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError("Error creating/getting AssignmentUnit", ex);
+            }
+
+            var attrNames = new List<string> { "FlightRing", "c:InstallLanguage" };
+            var attrData = AnalyticsInfo.GetSystemPropertiesAsync(attrNames).AsTask().GetAwaiter().GetResult();
+
+            var flightRing = string.Empty;
+            var installLanguage = string.Empty;
+
+            if (attrData.ContainsKey("FlightRing"))
+            {
+                flightRing = attrData["FlightRing"];
+            }
+
+            if (attrData.ContainsKey("InstallLanguage"))
+            {
+                installLanguage = attrData["InstallLanguage"];
+            }
+
+            return new VariantAssignmentRequest
+            {
+                Parameters =
+                {
+                    { "installLanguage", installLanguage },
+                    { "flightRing", flightRing },
+                    { "clientid", AssignmentUnit },
+                },
+            };
+        }
+
+        private string CreateFilePath()
+        {
+            var exeDir = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            var settingsPath = @"Microsoft\PowerToys\experimentation.json";
+            var filePath = Path.Combine(exeDir, settingsPath);
+            return filePath;
+        }
+    }
+}

src/common/AllExperiments/Logger.cs

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO.Abstractions;
+
+namespace AllExperiments
+{
+    public static class Logger
+    {
+        private static readonly IFileSystem FileSystem = new FileSystem();
+        private static readonly IPath Path = FileSystem.Path;
+        private static readonly IDirectory Directory = FileSystem.Directory;
+
+        private static readonly string ApplicationLogPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Microsoft\\PowerToys\\Settings Logs\\Experimentation");
+
+        static Logger()
+        {
+            if (!Directory.Exists(ApplicationLogPath))
+            {
+                Directory.CreateDirectory(ApplicationLogPath);
+            }
+
+            // Using InvariantCulture since this is used for a log file name
+            var logFilePath = Path.Combine(ApplicationLogPath, "Log_" + DateTime.Now.ToString(@"yyyy-MM-dd", CultureInfo.InvariantCulture) + ".txt");
+
+            Trace.Listeners.Add(new TextWriterTraceListener(logFilePath));
+
+            Trace.AutoFlush = true;
+        }
+
+        public static void LogInfo(string message)
+        {
+            Log(message, "INFO");
+        }
+
+        public static void LogError(string message)
+        {
+            Log(message, "ERROR");
+#if DEBUG
+            Debugger.Break();
+#endif
+        }
+
+        public static void LogError(string message, Exception e)
+        {
+            Log(
+                message + Environment.NewLine +
+                e?.Message + Environment.NewLine +
+                "Inner exception: " + Environment.NewLine +
+                e?.InnerException?.Message + Environment.NewLine +
+                "Stack trace: " + Environment.NewLine +
+                e?.StackTrace,
+                "ERROR");
+#if DEBUG
+            Debugger.Break();
+#endif
+        }
+
+        private static void Log(string message, string type)
+        {
+            Trace.WriteLine(type + ": " + DateTime.Now.TimeOfDay);
+            Trace.Indent();
+            Trace.WriteLine(GetCallerInfo());
+            Trace.WriteLine(message);
+            Trace.Unindent();
+        }
+
+        private static string GetCallerInfo()
+        {
+            StackTrace stackTrace = new StackTrace();
+
+            var methodName = stackTrace.GetFrame(3)?.GetMethod();
+            var className = methodName?.DeclaringType?.Name;
+            return "[Method]: " + methodName?.Name + " [Class]: " + className;
+        }
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Client/VariantAssignmentClientExtensionMethods.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.VariantAssignment.Contract;
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Client
+{
+#pragma warning disable SA1200 // Using directives should be placed correctly
+    using TreatmentAssignmentServiceClient = VariantAssignmentServiceClient<TreatmentAssignmentServiceResponse>;
+#pragma warning restore SA1200 // Using directives should be placed correctly
+
+    public static class VariantAssignmentClientExtensionMethods
+    {
+        public static IVariantAssignmentProvider GetTreatmentAssignmentServiceClient(this VariantAssignmentClientSettings settings)
+        {
+            return new TreatmentAssignmentServiceClient();
+        }
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Client/VariantAssignmentServiceClient.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.VariantAssignment.Contract;
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Client
+{
+    internal partial class VariantAssignmentServiceClient<TServerResponse> : IVariantAssignmentProvider, IDisposable
+        where TServerResponse : VariantAssignmentServiceResponse
+    {
+        public void Dispose()
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<IVariantAssignmentResponse> GetVariantAssignmentsAsync(IVariantAssignmentRequest request, CancellationToken ct = default)
+        {
+            return Task.FromResult(EmptyVariantAssignmentResponse.Instance);
+        }
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/EmptyVariantAssignmentResponse.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    public class EmptyVariantAssignmentResponse : IVariantAssignmentResponse
+    {
+        /// <summary>
+        /// Singleton instance of <see cref="EmptyVariantAssignmentResponse"/>.
+        /// </summary>
+        public static readonly IVariantAssignmentResponse Instance = new EmptyVariantAssignmentResponse();
+
+        public EmptyVariantAssignmentResponse()
+        {
+        }
+
+        public long DataVersion => 0;
+
+        public string Thumbprint => string.Empty;
+
+        /// <inheritdoc/>
+        public IReadOnlyCollection<IAssignedVariant> AssignedVariants => Array.Empty<IAssignedVariant>();
+
+        /// <inheritdoc/>
+#pragma warning disable CS8603 // Possible null reference return.
+        public IFeatureVariable GetFeatureVariable(IReadOnlyList<string> path) => null;
+#pragma warning restore CS8603 // Possible null reference return.
+
+        /// <inheritdoc/>
+        public IReadOnlyList<IFeatureVariable> GetFeatureVariables(IReadOnlyList<string> prefix) => Array.Empty<IFeatureVariable>();
+
+        void IDisposable.Dispose()
+        {
+        }
+
+        string IVariantAssignmentResponse.GetAssignmentContext()
+        {
+            throw new NotImplementedException();
+        }
+
+        IReadOnlyList<IFeatureVariable> IVariantAssignmentResponse.GetFeatureVariables()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/IAssignedVariant.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    public interface IAssignedVariant
+    {
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/IFeatureVariable.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    public interface IFeatureVariable
+    {
+        /// <summary>
+        /// Gets the variable's value as a string.
+        /// </summary>
+        /// <returns>String value of the variable.</returns>
+        string GetStringValue();
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/IVariantAssignmentProvider.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    public interface IVariantAssignmentProvider : IDisposable
+    {
+        /// <summary>
+        /// Computes variant assignments based on <paramref name="request"/> data.
+        /// </summary>
+        /// <param name="request">Variant assignment parameters.</param>
+        /// <param name="ct">Propagates notification that operations should be canceled.</param>
+        /// <returns>An awaitable task that returns a <see cref="IVariantAssignmentResponse"/>.</returns>
+        Task<IVariantAssignmentResponse> GetVariantAssignmentsAsync(IVariantAssignmentRequest request, CancellationToken ct = default);
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/IVariantAssignmentRequest.cs

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    public interface IVariantAssignmentRequest
+    {
+        /// <summary>
+        /// Gets inputs used for evaluating filters, assignment units, etc.
+        /// </summary>
+        IReadOnlyCollection<(string Key, string Value)> Parameters { get; }
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/IVariantAssignmentResponse.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    /// <summary>
+    /// Snapshot of variant assignments.
+    /// </summary>
+    public interface IVariantAssignmentResponse : IDisposable
+    {
+        ///// <summary>
+        ///// Gets the serial number of variant assignment configuration snapshot used when assigning variants.
+        ///// </summary>
+        long DataVersion { get; }
+
+        ///// <summary>
+        ///// Get a hash of the response suitable for caching.
+        ///// </summary>
+        // string Thumbprint { get; }
+
+        /// <summary>
+        /// Gets the variants assigned based on request parameters and a variant configuration snapshot.
+        /// </summary>
+        IReadOnlyCollection<IAssignedVariant> AssignedVariants { get; }
+
+        /// <summary>
+        /// Gets feature variables assigned by variants in this response.
+        /// </summary>
+        /// <param name="prefix">(Optional) Filter feature variables where <see cref="IFeatureVariable.KeySegments"/> contains the <paramref name="prefix"/>.</param>
+        /// <returns>Range of matching feature variables.</returns>
+        IReadOnlyList<IFeatureVariable> GetFeatureVariables(IReadOnlyList<string> prefix);
+
+        // this actually part of the interface but gets the job done
+        IReadOnlyList<IFeatureVariable> GetFeatureVariables();
+
+        // this actually part of the interface but gets the job done
+        string GetAssignmentContext();
+
+        /// <summary>
+        /// Gets a single feature variable assigned by variants in this response.
+        /// </summary>
+        /// <param name="path">Exact feature variable path.</param>
+        /// <returns>Matching feature variable or null.</returns>
+        IFeatureVariable GetFeatureVariable(IReadOnlyList<string> path);
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/TreatmentAssignmentServiceResponse.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    internal class TreatmentAssignmentServiceResponse : VariantAssignmentServiceResponse
+    {
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/VariantAssignmentClientSettings.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel.DataAnnotations;
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    /// <summary>
+    /// Configuration for variant assignment service client.
+    /// </summary>
+    public class VariantAssignmentClientSettings
+    {
+        /// <summary>
+        /// Gets or sets the variant assignment service endpoint URL.
+        /// </summary>
+        [Required]
+        public Uri? Endpoint { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether gets or sets a value whether client side request caching should be enabled.
+        /// </summary>
+        public bool EnableCaching { get; set; }
+
+        /// <summary>
+        /// Gets or sets the the maximum time a cached variant assignment response may be used without re-validating.
+        /// </summary>
+        public TimeSpan ResponseCacheTime { get; set; }
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/VariantAssignmentRequest.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Specialized;
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    public class VariantAssignmentRequest : IVariantAssignmentRequest
+    {
+        private NameValueCollection _parameters = new NameValueCollection();
+
+        /// <summary>
+        /// Gets or sets mutable <see cref="IVariantAssignmentRequest.Parameters"/>.
+        /// </summary>
+        public NameValueCollection Parameters { get => _parameters; set => _parameters = value; }
+
+        IReadOnlyCollection<(string Key, string Value)> IVariantAssignmentRequest.Parameters => (IReadOnlyCollection<(string Key, string Value)>)_parameters;
+    }
+}

src/common/AllExperiments/Microsoft.VariantAssignment/Contract/VariantAssignmentServiceResponse.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The goal of this class is to just mock out the Microsoft.VariantAssignment close source objects
+namespace Microsoft.VariantAssignment.Contract
+{
+    /// <summary>
+    /// Mutable implementation of <see cref="IVariantAssignmentResponse"/> for (de)serialization.
+    /// </summary>
+    internal class VariantAssignmentServiceResponse : IVariantAssignmentResponse, IDisposable
+    {
+        /// <inheritdoc />
+        public virtual long DataVersion { get; set; }
+
+        public virtual IReadOnlyCollection<IAssignedVariant> AssignedVariants { get; set; } = Array.Empty<IAssignedVariant>();
+
+        public IFeatureVariable GetFeatureVariable(IReadOnlyList<string> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IReadOnlyList<IFeatureVariable> GetFeatureVariables(IReadOnlyList<string> prefix)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        public IReadOnlyList<IFeatureVariable> GetFeatureVariables()
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetAssignmentContext()
+        {
+            return string.Empty;
+        }
+    }
+}