Reflection.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading;
 
using AnalyzeRe;
using AnalyzeRe.APIResourceView;
using AnalyzeRe.APITypes;
using AnalyzeRe.Attributes;
using AnalyzeRe.Distributions;
using AnalyzeRe.ExchangeRates;
using AnalyzeRe.Layers;
using AnalyzeRe.LossFilters;
using AnalyzeRe.LossSets;
using AnalyzeRe.Optimization;
using AnalyzeRe.Utilities;
using AnalyzeReTesting.Tests.Model;
using AnalyzeReTesting.Tests.Model.DataTypes;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
using TestCategory = NUnit.Framework.CategoryAttribute;
#endif
 
namespace AnalyzeReTesting.Utilities
{
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable")]
    public class Reflection
    {
        #region Properties
        private const int Recursions_Before_Calming_Down = 8;
 
        private const int Max_ReRandomize_Attempts = 20;
 
        private const int Max_Recursive_Calls = 16;
 
        private const double Min_Random = -1E9;
 
        private const double Max_Random = 1E9;
 
        private readonly ThreadLocal<Random> thread_safe_random;
 
        private Random _random => thread_safe_random.Value;
 
        private readonly Samples _samples;
 
        public AnalysisProfile Target_AnalysisProfile
        {
            get => !Validation_Enabled ? null : _targetAnalysisProfile ??
                (_targetAnalysisProfile = _samples.AnalysisProfile.Posted);
            set => _targetAnalysisProfile = value;
        }
        private AnalysisProfile _targetAnalysisProfile;
 
        public bool Validation_Enabled { get; set; } = true;
        #endregion Properties
 
        public Reflection(Samples samplesInstance = null, int? seedForRandom = null)
        {
            _samples = samplesInstance ?? new Samples();
 
            int seed = seedForRandom ?? Environment.TickCount;
            Console.WriteLine($"Seed for tests is: {seed} - but note that if tests are being run " +
                "concurrently, this seed cannot be used to reproduce the same results. " +
                "For a seed to guarantee the same results every time, tests must be run one at a time, " +
                "or with parallelism disabled on the test runner itself (MSTest or NUnit).");
            thread_safe_random = new ThreadLocal<Random>(() => new Random(seed));
        }
 
        public class RecursionContext
        {
            public Type Type { get; }
            public int Depth { get; }
            public RecursionContext Prior { get; }
 
            protected RecursionContext(Type objectType, int depth, RecursionContext prior)
            {
                Type = objectType;
                Depth = depth;
                Prior = prior;
            }
 
            public RecursionContext(Type objectType) : this(objectType, 0, null) { }
 
            public RecursionContext(Type objectType, int depth) : this(objectType, depth, null) { }
 
            public RecursionContext(Type objectType, RecursionContext prior)
                : this(objectType, (prior?.Depth + 1) ?? 0, prior) { }
 
            public bool MatchesCondition(Func<RecursionContext, bool> condition) =>
                condition(this) || HasParent(condition);
 
            public bool HasParent(Func<RecursionContext, bool> condition = null)
            {
                if (condition == null) return Prior != null;
                return Prior?.MatchesCondition(condition) ?? false;
            }
 
            [Conditional("DEBUG")]
            public void LogIndented(string log)
            {
                string indent = new string(' ', Depth * 2);
                Debug.WriteLine(indent +
                    log.Replace(Environment.NewLine, Environment.NewLine + indent));
            }
 
            public override string ToString() =>
                (Prior == null ? "Recursion Stack: " : $"{Prior} > ") + Type.NiceTypeName();
        }
 
        public T CreateRandomizedInstance<T>(RecursionContext parentRecursionInfo = null) =>
            (T)CreateRandomizedInstance(typeof(T), parentRecursionInfo);
 
        public object CreateRandomizedInstance(Type desiredType,
            RecursionContext parentRecursionInfo = null)
        {
            if (desiredType == null)
                throw new NullReferenceException("No desiredType parameter specified.");
            RecursionContext currentRecursion = new RecursionContext(desiredType, parentRecursionInfo);
            // If this type is a nullable, unwrap to the underlying type immediately.
            Type T = Nullable.GetUnderlyingType(desiredType) ?? desiredType;
#if DEBUG
            // Keep a log of each time we are about to randomly generate a non-trivial instance.
            if (!(T.IsPrimitive || T.IsValueType || T == typeof(object) || T == typeof(string)))
                currentRecursion.LogIndented($"Create randomized instance ({currentRecursion.Depth}): " +
                    $"{desiredType.NiceTypeName()}");
#endif
            // Different random generation behaviours based on the type. Trivial types first.
            // Random String
            if (T == typeof(string))
                return Output.RandomString(1, 100, _random);
            // Random Boolean
            else if (T == typeof(bool))
                return _random.Next(2) == 0;
            // Randomized Date
            else if (T == typeof(DateTime))
                return _samples.SimulationStartDate.AddDays(_random.Next(-365, 366));
            // Random int, long, etc...
            else if (T.IsIntegerType())
            {
                // Get the minimum value allowed by the type (e.g. 0 for unsigned types)
                long minSupported = Convert.ToInt64(T.GetField("MinValue").GetValue(null));
                // The minimum integer to generate is the most restrictive of the minimum
                // value supported by the type, and the configured minimum random number.
                int min = (int)Math.Max((long)Min_Random, minSupported);
                int random = _random.Next(min, (int)Max_Random);
                return Convert.ChangeType(random, T);
            }
            // Random double, decimal, etc...
            else if (T.IsNumeric())
            {
                double random = _random.NextDouble() * (Max_Random - Min_Random) + Min_Random;
                return Convert.ChangeType(random, T);
            }
            // Random enumeration value
            else if (T.IsEnum)
                return T.GetEnumValues().GetValue(_random.Next(T.GetEnumValues().Length));
            // Random arbitrary object (e.g. for metadata values) can be just about any primitive.
            else if (T == typeof(object))
                return CreateRandomizedInstance(_random.Next(5) == 0 ? typeof(string) :
                    _random.Next(4) == 0 ? typeof(bool) :
                    _random.Next(3) == 0 ? typeof(DateTime) :
                    _random.Next(2) == 0 ? typeof(int) : typeof(double), currentRecursion);
 
            // The following types are less trivial, but still system types
            // Random dictionary
            else if (typeof(IDictionary).IsAssignableFrom(T))
            {
                IDictionary dict = (IDictionary)Activator.CreateInstance(T);
                object key = CreateRandomizedInstance(T.GetGenericArguments()[0], currentRecursion);
                if (key is string strKey)
                {
                    // String dictionary keys cannot contain . or $ characters.
                    strKey = strKey.Replace(".", "").Replace("$", "");
                    // Bug ARE-7244: If the key is a string, but can be parsed as a number, it can cause errors
                    if (Double.TryParse(strKey, out _)) strKey = "Str" + strKey;
                    key = strKey;
                }
                // Insert a single item of the target type using the above key.
                dict.Add(key, CreateRandomizedInstance(T.GetGenericArguments()[1], currentRecursion));
                return dict;
            }
            // Random HashSet
            else if (T.IsGenericType && T.GetGenericTypeDefinition() == typeof(HashSet<>))
            {
                // Create a randomized list of the correct type, then insert them into a HashSet
                IList randList = CreateRandomizedList(T.GetGenericArguments()[0], currentRecursion);
                object hashSetResult = Activator.CreateInstance(T);
                // Have to use get and use the strongly typed Add method of the generic HashSet
                MethodInfo addMethod = T.GetMethod("Add");
                foreach (object toAdd in randList.Cast<object>())
                    addMethod.Invoke(hashSetResult, new[] { toAdd });
                return hashSetResult;
            }
            // Random List of items.
            else if (typeof(IList).IsAssignableFrom(T))
            {
                Type itemsType = TypeResolver.GetEnumerableType(T);
                IList randomList = CreateRandomizedList(itemsType, currentRecursion);
                // If the generated list can be assigned directly to the target type, return it directly.
                if (T.IsInstanceOfType(randomList))
                    return randomList;
                // Otherwise, create a new instance of the same type, and add all items
                if (T.IsAbstract || T.IsInterface)
                    throw new ArgumentException($"Unsure how to construct a new {T.NiceTypeName()} " +
                        "because it is an abstract class or interface.");
                try
                {
                    // As far as I know, all types that implement IList (including arrays) can be
                    // constructed from an array of objects of the list type. If this fails for
                    // certain list types, we may need to add a check above and construct differently.
                    return (IList)Activator.CreateInstance(T, randomList.Cast<object>().ToArray());
                }
                catch (Exception ex)
                {
                    throw new ArgumentException($"An attempt to construct a new {T.NiceTypeName()} " +
                        $"from an array of {itemsType.NiceTypeName()} failed: {ex.Message}", ex);
                }
            }
 
            // Random APIType or APIResource (i.e. custom types)
            else if (typeof(IAPIType).IsAssignableFrom(T))
            {
                // Defer to a specialized method for randomly generating custom API type instances
                return CreateRandomizedAPIType(T, currentRecursion);
            }
 
            // Unknown type, can't be randomly generated
            string message = $"No rules for generating a random value of type: \"{T.NiceTypeName()}\".";
            currentRecursion.LogIndented(message);
            // Only fail if this is a top-level instance generation. Otherwise, try returning null
            if (currentRecursion.Depth == 0)
                Assert.Fail(message);
            return T.IsValueType ? Activator.CreateInstance(T) : null;
        }
 
        #region Type Specific Random Generation Helpers
        private IReference<T> CreateRandomizedReference<T>(RecursionContext currentRecursion,
            bool allowReuseOfExisting = true) where T : IAPIResource =>
            (IReference<T>)CreateRandomizedReference(typeof(IReference<T>), currentRecursion, allowReuseOfExisting);
 
        private IReference<IAPIResource> CreateRandomizedReference(Type referenceType,
            RecursionContext currentRecursion, bool allowReuseOfExisting = true)
        {
            if (referenceType == null)
                throw new ArgumentNullException(nameof(referenceType));
            if (!typeof(IReference).IsAssignableFrom(referenceType) || !referenceType.IsGenericType)
                throw new ArgumentException("This function requires a generic reference type. " +
                    $"The type given was {referenceType.NiceTypeName()}");
 
            // Extract the resource type we wish to create a reference to (we call this T for compactness)
            Type T = referenceType.GetGenericArguments()[0];
 
            // If we do not need a valid reference, return a reference to a random GUID
            if (!Validation_Enabled)
            {
                Type runtimeType = typeof(Reference<>).MakeGenericTypeFast(T);
                ConstructorInfo referenceConstructor = runtimeType.GetConstructor(new[] { typeof(string) });
                if (referenceConstructor == null)
                    throw new Exception($"Missing Reference Constructor {runtimeType.NiceTypeName()}(string)");
                // Construct the new reference using the deserialized data.
                return (IReference<IAPIResource>)referenceConstructor.Invoke(
                    new object[] { Guid.NewGuid().ToString() });
            }
            if (typeof(ILayerSource) == T)
                throw new Exception($"CreateRandomizedReference called for a type {referenceType.NiceTypeName()}, " +
                    "but this routine should not being used for IReference<ILayerSource> properties. " +
                    "All those properties should be using GenerateNestedLayerSourceReference.");
 
            // To avoid spending too much time posting random new resources, if we need a reference
            // to an APIResource, we will sometimes opt to search the server for an existing
            // resource rather than POST a new one and then reference it.
            // TODO: This is almost the same as the logic used to decide whether to generate
            //       a new IAPIResource or find an existing one in CreateRandomizedAPIType.
            //       consider consolidating this logic.
            bool reuse_existing;
            // Favour generating a new resource from scratch if we're still generating the first
            // level of properties - since most tests want root level properties randomized.
            if (currentRecursion.Depth < 2 || !allowReuseOfExisting)
                reuse_existing = false;
            // Conversely, always try to use an existing resource if we've recursed quite a lot.
            else if (currentRecursion.Depth >= Recursions_Before_Calming_Down)
                reuse_existing = true;
            // Otherwise there's a 1/2 chance we try getting a reference to an existing one first.
            // If it has a data endpoint, make it a 3/4 chance, to avoid costly file uploads.
            else
                reuse_existing = 0 < _random.Next(
                    typeof(IAPIResource_WithDataEndpoint).IsAssignableFrom(T) ? 4 : 2);
 
            // If the above logic decided we will be re-using an existing resource, do so
            if (reuse_existing)
            {
                currentRecursion.LogIndented("Opted to find an existing resource of type " +
                    $"{T.NiceTypeName()} on thread {Thread.CurrentThread.ManagedThreadId}");
                IReference<IAPIResource> existing = GetRandomExistingResource(T, currentRecursion);
                // We should return a copy of the existing resource, in case the caller intends to modify it.
                if (existing != null)
                    return existing;
                currentRecursion.LogIndented($"No satisfactory existing {T.NiceTypeName()} found. " +
                    "Reverting to generating a new resource.");
            }
 
            // Create a new (unposted) randomized instance of the specified type.
            IAPIResource res = (IAPIResource)CreateRandomizedInstance(T, currentRecursion);
 
            // If successful, post our new randomly generated object so that it is valid to reference.
            if (res != null)
            {
                string reqDescription = $"Post a randomly generated {T.NiceTypeName()}";
                BeginRequest(currentRecursion, reqDescription);
 
                try { res = res.Post(); }
                catch (APIRequestException ex)
                {
                    string error = $"Failed to generate a valid {T.NiceTypeName()}. " +
                        $"Post of the resource to reference failed with: {ex.Message}" +
                        $"\nStructure looks like:\n{res.Serialize()}";
                    Console.WriteLine(error);
                    EndRequest(reqDescription, error);
                    throw;
                }
                // If this resource has a data endpoint, we must upload something against it to finalize it.
                res = FinalizePostedResource(res);
 
                EndRequest(reqDescription);
 
                IReference<IAPIResource> asReference = res.ToReference(true);
                CacheResource(asReference);
                return asReference;
            }
 
            // If we've recursed too deeply or otherwise failed to create a new reference to an
            // allowed type, return a null reference and hope it doesn't cause any problems upstream.
            currentRecursion.LogIndented($"Failed to generate a valid {T.NiceTypeName()}. Returning null.");
            return null;
        }
 
        private List<T> CreateRandomizedList<T>(RecursionContext currentRecursion) =>
            CreateRandomizedList(typeof(T), currentRecursion).Cast<T>().ToList();
 
        private IList CreateRandomizedList(Type contentType, RecursionContext currentRecursion)
        {
            if (contentType == null) throw new ArgumentNullException(nameof(contentType));
 
            // Otherwise, create a new list and insert one or more random items in it.
            IList result = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericTypeFast(contentType));
            // See how many instantiable types match the desired type.
            // (If generic type is object, we can't get instantiable sub-types)
            List<Type> subtypes = typeof(IAPIType).IsAssignableFrom(contentType) ?
                GetAllInstantiableSubtypes(contentType).ToList() : new List<Type> { contentType };
            // If we haven't recursed much, try to put one of every possible type of item in the list.
            if (currentRecursion.Depth < 2 && subtypes.Count > 1)
            {
                currentRecursion.LogIndented("Recursion Level is low, generating a reference to " +
                    $"every instantiable subtype of {contentType.NiceTypeName()}.");
                subtypes.Select(t => CreateRandomizedInstance(t, currentRecursion))
                    .Where(x => x != null).ToList().ForEach(x =>
                    {
                        // If this is a reference list, don't add the same reference to the list twice
                        // (can happen randomly when two types share a common instantiable base.)
                        bool isDuplicate = (typeof(IReference).IsAssignableFrom(contentType) &&
                            result.Cast<IReference>().Any(r => r.ref_id == ((IReference)x).ref_id));
                        if (!isDuplicate)
                            result.Add(x);
                    });
            }
            // Otherwise, randomly pick just one item to put in the list.
            // (If we reached the max number of recursions, just return the empty list)
            else if (currentRecursion.Depth < Max_Recursive_Calls)
            {
                object toAdd = CreateRandomizedInstance(contentType, currentRecursion);
                if (toAdd != null)
                    result.Add(toAdd);
            }
            return result;
        }
 
        private T CreateRandomizedAPIType<T>(RecursionContext currentRecursion) where T : IAPIType =>
            (T)CreateRandomizedAPIType(typeof(T), currentRecursion);
 
        private IAPIType CreateRandomizedAPIType(Type T, RecursionContext currentRecursion)
        {
            // Try to create a new random object of this type.
            try
            {
                if (T == null || !typeof(IAPIType).IsAssignableFrom(T))
                    throw new ArgumentException($"The desired type {T.NiceTypeName()} must derive from IAPIType.");
 
                // Avoid recursing too deeply. Try returning null (hopefully it isn't for a required field)
                int recursionLevel = currentRecursion.Depth;
                if (recursionLevel > Max_Recursive_Calls)
                {
                    currentRecursion.LogIndented($"Recursion level ({recursionLevel}) is too high " +
                        $"({Max_Recursive_Calls}) to generate a new resource. Returning a null object.");
                    return null;
                }
 
                // Immutable types and types without a default constructor must be handled differently.
                if (typeof(IReference).IsAssignableFrom(T))
                    return CreateRandomizedReference(T, currentRecursion);
                if (typeof(Perspective).IsAssignableFrom(T))
                    return CreateRandomizedPerspective(currentRecursion);
 
                // If we're nearing our maximum recursion level try finding an existing resource
                // Rather than randomly generating a new one.
                if (recursionLevel > Recursions_Before_Calming_Down && typeof(IAPIResource).IsAssignableFrom(T))
                {
                    currentRecursion.LogIndented($"Recursion level ({recursionLevel}) is getting high " +
                        $"(>{Recursions_Before_Calming_Down}) - looking for existing resources " +
                        $"of type {T.NiceTypeName()}");
                    IReference<IAPIResource> existing = GetRandomExistingResource(T, currentRecursion);
                    // We should clone the resource in case the caller intends to modify the returned object.
                    if (existing != null)
                        return Resolve(existing).DeepCopy();
                    // If that failed for whatever reason, revert to generating a new random resource.
                }
 
                // If T is abstract base class or an interface for a custom type,
                // we must pick a random instantiable sub-type to generate a new instance of.
                Type instantiableType = T;
                RecursionContext nextRecursion = currentRecursion;
                if (T.IsInterface || T.IsAbstract)
                {
                    List<Type> instanceTypes = GetAllInstantiableSubtypes(T).ToList();
                    if (instanceTypes.Count == 1)
                        instantiableType = instanceTypes.Single();
                    // If there's more than one compatible instantiable type, pick a random one
                    else
                    {
                        instantiableType = instanceTypes.OrderBy(t => _random.NextDouble()).First();
                        nextRecursion = new RecursionContext(instantiableType, currentRecursion);
                        nextRecursion.LogIndented("Elected to generate an instance of the " +
                            $"instantiable derived type: {instantiableType.NiceTypeName()}");
                    }
                }
 
                // Otherwise, create a new instance of the requested type and randomize its properties.
                if (instantiableType.GetConstructor(Type.EmptyTypes) == null)
                    throw new PropertyGenerationException("Cannot create an instance of the type " +
                        $"{instantiableType.NiceTypeName()} because it has no empty constructor.");
                IAPIType newInstance = (IAPIType)Activator.CreateInstance(instantiableType);
                return GenerateRandomAPITypeProperties(newInstance, nextRecursion);
            }
            catch (PropertyGenerationException e)
            {
                currentRecursion.LogIndented(e.Message + " Returning null object.");
                // If this was a recursive call generating a sub-resource, try just returning null,
                // otherwise, re-throw the exception.
                if (currentRecursion.Depth > 0)
                    return null;
                throw;
            }
        }
 
        private Perspective CreateRandomizedPerspective(RecursionContext currentRecursion)
        {
            // Chance to use a random pre-defined perspective instance
            if (_random.Next(2) == 0)
            {
                Perspective[] perspectives = TestSuite_Perspective.TestPerspectives.ToArray();
                return perspectives[_random.Next(perspectives.Length)];
            }
            // Generate a perspective from a random set of perspective values that are arbitrarily combinable
            List<Perspective.Base> values = TestSuite_Perspective.CombinablePerspectiveValues
                .Where(p => _random.Next(2) == 0).ToList(); // 50% chance of including each perspective value
            // Ensure there is at least one
            if (values.Count == 0) values.Add(
                TestSuite_Perspective.AllPerspectiveValues[_random.Next(TestSuite_Perspective.AllPerspectiveValues.Length)]);
            return Perspective.FromEnums(values);
        }
 
        public IReference<IAPIResource> GetRandomExistingResource(Type T, RecursionContext currentRecursion)
        {
            // Special case, it's unsafe to randomly pick these from existing resources,
            //   as they will almost always result in an invalid resource for posting.
            //   We need to use specifically the resources compatible with Target_AnalysisProfile
            if (Validation_Enabled)
            {
                IReference<IAPIResource> reference_from_analysis_profile = null;
                if (typeof(AnalysisProfile).IsAssignableFrom(T))
                    reference_from_analysis_profile = Target_AnalysisProfile.ToReference();
                if (typeof(Simulation).IsAssignableFrom(T))
                    reference_from_analysis_profile = Target_AnalysisProfile.simulation;
                if (typeof(EventCatalog).IsAssignableFrom(T))
                    reference_from_analysis_profile = Target_AnalysisProfile.event_catalogs.First();
                if (typeof(LossFilter).IsAssignableFrom(T))
                    reference_from_analysis_profile = Target_AnalysisProfile.loss_filters[
                        _random.Next(Target_AnalysisProfile.loss_filters.Count)];
                if (reference_from_analysis_profile != null)
                {
                    currentRecursion.LogIndented($"Opted to reuse the {T.NiceTypeName()} " +
                        $"referenced by the target analysis profile ({Target_AnalysisProfile.id})");
                    CacheResource(reference_from_analysis_profile);
                    return reference_from_analysis_profile;
                }
 
                // Data file references are a special case. To be valid, we should pick a reference
                // to a data file used on a valid resource of the same type.
                if (T == typeof(DataFile) && currentRecursion.Type != null &&
                    typeof(IAPIResource_WithDataEndpoint).IsAssignableFrom(currentRecursion.Type))
                {
                    currentRecursion.LogIndented("Opted to look for an existing " +
                        $"{currentRecursion.Type.NiceTypeName()} whose data file we can copy)");
                    return (Resolve(GetRandomExistingResource(currentRecursion.Type, currentRecursion))
                        as IAPIResource_WithDataEndpoint)?.data_file;
                }
            }
 
            // See if the requested type matches any previously retrieved or created resources
            // Get the set of cached resources for this type (this enumerable should be returned
            // in a deterministic order) then randomize the order in some new seeded way.
            IEnumerable<IReference<IAPIResource>> elegibleReferences =
                CachedResourcesOfType(T).OrderBy(random => _random.NextDouble());
            // Filter references to ensure we only look at ones compatible with the current analysis profile.
            elegibleReferences = !Validation_Enabled ? elegibleReferences : elegibleReferences.Where(
                reference => ResourceIsValidForAnalysisProfile(Resolve(reference), Target_AnalysisProfile));
            // If our recursion context has imposed restrictions on what types of layers can be
            // nested within, ensure there are no forbidden layer types in the new reference.
            if (typeof(ILayerSource).IsAssignableFrom(T) && GetLayerSourceRestrictions(currentRecursion)
                is HashSet<Type> restrictedTypes && restrictedTypes.Any())
            {
                elegibleReferences = elegibleReferences.Cast<IReference<ILayerSource>>()
                    .Where(reference => !AnyLayerSourceMatchesCriteria(Resolve(reference),
                        source => restrictedTypes.Contains(GetLayerDefinition(source).GetType())));
            }
 
            // Select the first random reference that passes validation (if applicable)
            IReference<IAPIResource> selectedForReuse = elegibleReferences.FirstOrDefault();
            if (selectedForReuse != null)
            {
                string description = !selectedForReuse.resolved ? null :
                    $"description: \"{(selectedForReuse.GetValue() as IStoredAPIResource)?.description}\" ";
                currentRecursion.LogIndented($"Opted to reuse a previously found/generated " +
                    $"{selectedForReuse.GetType().NiceTypeName()} from the recursion context " +
                    $"({description}id: {selectedForReuse.ref_id})");
                return selectedForReuse;
            }
 
            // ResourceIsValidForAnalysisProfile does not protect against there being existing resources
            // on the server that violate some of the trickier validation criteria that RandomizePropertyValue
            // checks for. As such, we've disabled re-using random resources on the server.
            //string request = $"Search server for existing {T.NiceTypeName()}";
            //BeginRequest(currentRecursion, request);
            //IReference<IAPIResource> existing = SearchServerForRandomExistingResource(T, currentRecursion);
            //EndRequest(request, existing == null ? "(None Found)" : $"Success: using {existing.ref_id}");
            //if (existing != null)
            //    return existing;
 
            // If neither of the above approaches worked, check to see if one of our standard
            // injectable resources used throughout the test framework can be used.
            // Assume it cannot if validation is enabled and the default sample analysis profile
            // doesn't match the current target analysis profile.
            if ((Target_AnalysisProfile.id == _samples.AnalysisProfile.Posted.id ||
                !Validation_Enabled) && GetSampleOfType(T) is IReference<IAPIResource> sample)
            {
                currentRecursion.LogIndented($"Opted to use a standard sample {T.NiceTypeName()}");
                return sample;
            }
 
            // Return null if no resources we found satisfied the list.
            currentRecursion.LogIndented($"Could not find any existing {T.NiceTypeName()} to reference.");
            return null;
        }
 
        public IReference<IAPIResource> GetSampleOfType(Type T)
        {
            HashSet<Type> unpostableTypes = GetUnsupportedTypes();
            IOrderedEnumerable<PropertyInfo> matchingSamples = typeof(Samples).GetPublicProperties_Fast()
                // Only look for properties that are IInjectableResource of a usable type.
                .Where(p => p.PropertyType.IsSubclassOfRawGeneric(typeof(IInjectableResource<>)) &&
                    p.PropertyType.GetGenericArguments()[0] is Type sampleType &&
                    T.IsAssignableFrom(sampleType) && !unpostableTypes.Contains(sampleType))
                .OrderBy(random => _random.NextDouble());
            IEnumerable<IInjectableResource<IAPIResource>> eligibleSamples = matchingSamples.Select(
                property => (IInjectableResource<IAPIResource>)property.GetValue(_samples));
 
            // Return the first (after random ordering) eligible sample (or null).
            IReference<IAPIResource> matchingSample = eligibleSamples.FirstOrDefault()?.AsReference;
            if (matchingSample != null)
                CacheResource(matchingSample);
            return matchingSample;
        }
 
        #region Cached Existing Resources
        private uint _trackInsertionOrder = 0;
 
        private readonly ConcurrentDictionary<Type,
                ConcurrentDictionary<IReference<IAPIResource>, Tuple<uint, IReference<IAPIResource>>>>
            _knownResourcesByType = new ConcurrentDictionary<Type,
                ConcurrentDictionary<IReference<IAPIResource>, Tuple<uint, IReference<IAPIResource>>>>();
 
        public IReference<T> CacheResource<T>(T resource) where T : IAPIResource =>
            CacheResource(resource.GetType(), resource.ToReference(true));
 
        public IReference<T> CacheResource<T>(IReference<T> reference) where T : IAPIResource =>
            // If the resource stored in this reference is more strongly-typed than the reference container
            // itself, cache it as a strongly-typed reference, which may have more re-use cases.
            reference.ResourceType == typeof(T) ? CacheResource(typeof(T), reference) :
                // A resolved reference's ResourceType is the resolved value's runtime type
                reference.resolved ? CacheResource(reference.GetValue()) :
                // Otherwise, it represents the runtime type of the reference container
                CacheResource(reference.ResourceType, reference);
 
        private IReference<T> CacheResource<T>(Type resourceType, IReference<T> reference) where T : IAPIResource
        {
            if (reference.ref_id == null)
                throw new ArgumentException("Cannot cache resources that have not been posted.");
            IReference<IAPIResource> cached = (IReference<IAPIResource>)reference;
            ConcurrentDictionary<IReference<IAPIResource>, Tuple<uint, IReference<IAPIResource>>> dictForType =
                _knownResourcesByType.GetOrAdd(resourceType, t =>
                    new ConcurrentDictionary<IReference<IAPIResource>, Tuple<uint, IReference<IAPIResource>>>());
            // Add to our cache. If a duplicate is already cached in there, return it instead
            cached = dictForType.GetOrAdd(cached, c => Tuple.Create(_trackInsertionOrder++, c)).Item2;
            return cached is IReference<T> typedCached ? typedCached :
                throw new InvalidCastException($"The {reference.GetType().NiceTypeName()} was " +
                    $"previously cached as a more weakly typed {cached.GetType().NiceTypeName()} " +
                    "which is preventing the cached instance from being reused now.");
        }
 
        private IEnumerable<IReference<IAPIResource>> CachedResourcesOfType(Type T) =>
            // First, get all cache dictionaries compatible with the requested type
            _knownResourcesByType.Where(kvp => kvp.Key == T || T.IsAssignableFrom(kvp.Key))
                // Ensure individual dictionaries are returned in a deterministic order
                .OrderBy(typeDictPair => typeDictPair.Key.GetHashCode())
                // Combine the items cached in all compatible dictionaries
                .SelectMany(typeDictPair => typeDictPair.Value
                    // Order the elements in each dictionary based on the insertion order
                    // values (Item1), but return only the cached items themselves (Item2).
                    .Values.OrderBy(t => t.Item1).Select(t => t.Item2));
 
        public T Resolve<T>(IReference<T> reference) where T : class, IAPIResource
        {
            if (!Validation_Enabled)
                throw new Exception("Resolve should not be used when reflection class " +
                    "is configured for offline resource generation.");
            if (reference == null) return null;
            if (reference.ref_id == null)
                return reference.resolved ? reference.GetValue() :
                    throw new ArgumentException("Cannot resolve references with no id");
            // Ensure that anyone resolving a reference to this id is sharing the same resolved
            // instance, so that once the value is resolved once, it's never retrieved again.
            return CacheResource(reference).GetValue();
        }
        #endregion Cached Existing Resources
 
        public T FinalizePostedResource<T>(T posted) where T : IAPIResource
        {
            T finalized = posted;
            if (posted is IAPIResource_WithDataEndpoint asWithData)
                finalized = (T)UploadResourceData(asWithData).Get();
            else if (posted is IStoredAPIResource_WithStatus asWithStatus && !asWithStatus.status.IsProcessingComplete())
                finalized = (T)asWithStatus.PollUntilReady(Samples.DataPollingOptions).Get();
            // Only cache resources that have no status, or that completed processing succeffully.
            if (finalized != null && (!(finalized is IStoredAPIResource_WithStatus withStatus) ||
                withStatus.status == TaskStatus.Success))
            {
                CacheResource(finalized);
            }
            return finalized;
        }
 
        public T UploadResourceData<T>(T resource) where T : IAPIResource_WithDataEndpoint
        {
            try
            {
                // If the resource has already been supplied a data file reference,
                // no additional upload necessary, just poll until its data is ready.
                if (resource.data_file != null)
                {
                    Debug.WriteLine("UploadResourceData was give a resource that already has a data_file " +
                        $"reference ({resource.data_file.ref_id}). Polling until ready.");
                    return resource.PollUntilReady(Samples.DataPollingOptions);
                }
 
                // Otherwise, get the data to upload
                string dataToUpload = null;
                if (resource is StaticSimulation)
                    dataToUpload = Samples.CSV.Static_Simulation_Data;
                else if (resource is ELTLossSet)
                    dataToUpload = Samples.CSV.Loss_Set_1_Data;
                else if (resource is YLTLossSet)
                    dataToUpload = Samples.CSV.YLTLossSet_10Trials;
                else if (resource is YELTLossSet)
                {
#pragma warning disable CS0618 // TODO: Remove when binary code is deprecated
                    dataToUpload = ((YELTLossSet)(IAPIResource_WithDataEndpoint)resource).data_type ==
                    YELTLossSet.DataType.binary ? Samples.CSV.YELTLossSet_10Trials_ForBinary :
#pragma warning restore CS0618
                    Samples.CSV.YELTLossSet_10Trials;
                }
                else if (resource is EventCatalog)
                    dataToUpload = Samples.CSV.Event_Catalog_Data;
                else if (resource is ExchangeRateTable)
                    dataToUpload = Samples.CSV.Exchange_Rate_Table;
                else if (resource is CustomFrequencyDistribution)
                    dataToUpload = Samples.CSV.CustomFrequencyDistribution_Data;
                else if (resource is CustomSeasonalityDistribution)
                    dataToUpload = Samples.CSV.CustomSeasonalityDistribution_Data;
                else if (resource is CustomSeverityDistribution)
                    dataToUpload = Samples.CSV.CustomSeverityDistribution_Data;
 
                if (dataToUpload == null)
                    Assert.Fail("Reflection-based data upload error: Not sure what sort of " +
                        $"data to upload for this resources of type: {resource.GetType()}");
 
                resource.data.UploadString(dataToUpload, Samples.UploadParams);
                return resource.PollUntilReady(Samples.DataPollingOptions);
            }
            catch (Exception ex)
            {
                // Log more information so we can debug this error
                string error = "Upload data failed for resource of type " +
                    $"{resource.GetType().NiceTypeName()} failed: {ex.Message}" +
                    $"\nStructure looks like:\n{resource.Serialize()}";
                Console.WriteLine($"Error: {error}");
                throw new APIRequestException(error, ex);
            }
        }
 
        // These properties must be assigned first because other properties are derived from them.
        // Larger number is higher priority
        private static readonly Dictionary<string, int> _propertyPriorities = new Dictionary<string, int>
        {
            { nameof(IAPIAnalysis.analysis_profile), 4 }, { nameof(ILayerView.layer), 3 },
            { nameof(AttributeFilter.attribute), 2 }, { nameof(IAPIResourceView.target_currency), 2 },
            { nameof(AnalysisProfile.simulation), 1 }, { nameof(AnalysisProfile.event_catalogs), 1 },
            { nameof(RangeFilter.begin_value), 1 }, { nameof(UniformDistribution.lower), 1 },
            { nameof(ILayer_WithTerms.inception_date), 1 }, { nameof(FixedDatePayment.payments), 1 },
            { nameof(Nested.sink), 1 }
        };
 
        private IAPIType GenerateRandomAPITypeProperties(IAPIType result, RecursionContext currentRecursion)
        {
            Type T = result.GetType();
            // Loop over the properties of the object we've instantiated and give them random values.
            // These properties must be assigned first because other properties are derived from them.
            foreach (PropertyInfo prop in T.GetUserFacingProperties(true, true).OrderByDescending(
                p => _propertyPriorities.TryGetValue(p.Name, out int propPriority) ? propPriority : 0))
            {
                if (!prop.CanWrite)
                    throw new Exception("GetUserFacingProperties returned a read-only property " +
                        "even though only writable properties were requested. Property was: " +
                        $"{T.NiceTypeName()} property {prop.PropertyType.NiceTypeName()} " +
                        $"{prop.DeclaringType.NiceTypeName()}.{prop.Name}");
                // Users can either user the data property or the data upload endpoint.
                // We will be using the latter, so skip generating a property for this value.
                if (IsProperty<IAPIResource_WithDataEndpoint>(prop, r => r.data_file))
                    continue;
                int max_attempts = currentRecursion.Depth >= Recursions_Before_Calming_Down ? 1
                    : Max_ReRandomize_Attempts;
                string last_error = null;
                object propertyValue = LimitAttempts(() =>
                    {
                        try
                        {
                            return RandomizePropertyValue(result, prop, currentRecursion);
                        }
                        catch (PropertyGenerationException ex)
                        {
                            last_error = ex.Message;
                            return ex;
                        }
                    }, o => !(o is PropertyGenerationException),
                    () => "RandomizePropertyValue method failed: " + last_error,
                    prop, max_attempts, recursionInfo: currentRecursion);
                prop.SetValue(result, propertyValue);
            }
            return result;
        }
 
        internal object RandomizePropertyValue(IAPIType obj, PropertyInfo prop, RecursionContext currentRecursion)
        {
            if (obj == null && Validation_Enabled)
                throw new ArgumentNullException(nameof(obj),
                    "An object instance is required for several validation checks.");
            object propertyValue;
            // All data_file references should be left null, we will upload data manually.
            if (Validation_Enabled && IsProperty<IAPIResource_WithDataEndpoint>(prop, s => s.data_file))
                throw new ArgumentException("Cannot reliably generate data_file references. " +
                    "The caller should make sure they are handling this property appropriately.");
            // TODO: In certain conditions the currency needs to be locked down
            // e.g. all exchange rate tables must have a base currency of USD to match the data?
            //else if (IsProperty<ExchangeRateTable>(prop, s => s.base_currency))
            //{
            //    propertyValue = Validation_Enabled ? "USD" : GetRandomCurrency();
            //}
            else if (prop.Name.Contains("currency"))
            {
                propertyValue = GetRandomCurrency();
            }
            // The configured "Target_AnalysisProfile" dictates what analysis profile must be used
            else if (Validation_Enabled && IsProperty<IAPIAnalysis>(prop, p => p.analysis_profile))
            {
                propertyValue = Target_AnalysisProfile.ToReference();
            }
            // The configured "Target_AnalysisProfile" dictates what event_catalog must be used
            else if (Validation_Enabled && (
                IsProperty<ILossSet_WithEventCatalog>(prop, p => p.event_catalogs) ||
                IsProperty<Simulation>(prop, p => p.event_catalogs) ||
                IsProperty<AnalysisProfile>(prop, p => p.event_catalogs)))
            {
                propertyValue = Target_AnalysisProfile.event_catalogs;
            }
            // StaticSimulation and pre-simulated loss sets' 'trial_count' must match the uploaded data.
            else if (Validation_Enabled && (IsProperty<StaticSimulation>(prop, s => s.trial_count) ||
                IsProperty<ILossSet_Simulated>(prop, a => a.trial_count)))
            {
                // In this case we know the trial count of all sample data for testing is 10 trials,
                // but just so we can mix it up a bit - the server won't complain if the stated
                // trial count is larger than what's in the data. e.g. the data can be sparse.
 
                // The exception is if this Simulation belongs to a QCLSLossSet - in that case, the trial
                // count of the simulation must match the target analysis profile.
                if (currentRecursion.MatchesCondition(r => r.Type == typeof(QCLSLossSet)))
                    propertyValue = (Resolve(Target_AnalysisProfile.simulation) as StaticSimulation)?.trial_count ??
                        throw new ArgumentException("Expected the target analysis profile to have a static simulation.");
                else
                    propertyValue = _random.Next(10, 20);
            }
            // In order to use the above rule, we have to ensure that QCLSLossSet's static simulation is not
            // picked at random from existing resources (a possibility if using the default generation behaviour)
            // Also provide a chance that it will simply re-use the target analysis profile's simulation.
            else if (Validation_Enabled && IsProperty<QCLSLossSet>(prop, ls => ls.simulation))
            {
                propertyValue = _random.NextDouble() < 0.5 ? Target_AnalysisProfile.simulation :
                    CreateRandomizedReference(prop.PropertyType,
                        new RecursionContext(prop.PropertyType, currentRecursion), allowReuseOfExisting: false);
            }
            // If generating a Filter LayerView requires we use filters from the analysis profile.
            else if (Validation_Enabled && IsProperty<Filter>(prop, p => p.filters))
            {
                // Hack: Again, use the known valid analysis profile which is going to be
                //       used for all randomly generated view objects.
                propertyValue = new List<IReference<LossFilter>>(
                    Target_AnalysisProfile.loss_filters.OrderBy(t => _random.NextDouble())
                        .Take(_random.Next(Target_AnalysisProfile.loss_filters.Count)));
            }
            // FixedDatePayment requires as at least many payment dates as payments
            else if (Validation_Enabled && IsProperty<FixedDatePayment>(prop, p => p.payment_dates))
            {
                // If payments aren't set yet, randomly generate between 1 and 10 dates
                // otherwise, ensure we don't generate fewer than there are payments.
                int payment_count = ((FixedDatePayment)obj)?.payments?.Count ?? 1;
                List<DateTime> dates = Enumerable.Range(0, _random.Next(payment_count, 11))
                    // Ensure all payment dates are well after the end of the simulation year,
                    // to avoid runtime errors about insufficient payments after the last loss.
                    .Select(_ => _samples.SimulationStartDate.AddYears(2).AddDays(_random.Next(366)))
                    .OrderBy(date => date).ToList();
                // Below is not necessary so long as sequences are predictable.
                //DateTime UTCLastDay = new DateTime(9999, 12, 31, 0, 0, 0, 0, DateTimeKind.Utc);
                //dates.AddRange(Enumerable.Repeat(UTCLastDay, payment_count));
                propertyValue = dates;
            }
            else if (Validation_Enabled && IsProperty<FixedDatePayment>(prop, p => p.payments))
            {
                // If payment_dates aren't set yet, randomly generate between 1 and 10 payments
                // otherwise, ensure we don't generate more than there are payment_dates.
                int payment_date_count = ((FixedDatePayment)obj)?.payment_dates?.Count ?? 10;
                propertyValue = Enumerable.Range(0, _random.Next(1, payment_date_count + 1))
                    .Select(_ => _random.NextDouble()).ToList();
            }
            // In order to ensure the above payment dates are sufficient, restrict randomly generated
            // loss sets to types with predictable sequences (no parametric or nested layer loss sets)
            // TODO: Downside is we have no test coverage for parametrics/NLLS used in this situation
            else if (IsProperty<FixedDatePayment>(prop, p => p.loss_sets))
                propertyValue = CreateRandomizedList<IReference<LossSet_WithData>>(currentRecursion)
                    .Cast<IReference<LossSet>>().ToList();
            // ValueAllocators currently allow all base perspectives except for LossGross.
            else if (IsProperty<ValueAllocator>(prop, va => va.allocation_perspectives))
            {
                List<ValueAllocator.Perspective> newValue = new List<ValueAllocator.Perspective>();
                // 1/3 Chance to include each perspective in the list.
                if (_random.Next(3) == 0) newValue.Add(ValueAllocator.Perspective.LossNetOfAggregateTerms);
                if (_random.Next(3) == 0) newValue.Add(ValueAllocator.Perspective.ReinstatementPremium);
                if (_random.Next(3) == 0) newValue.Add(ValueAllocator.Perspective.ReinstatementBrokerage);
                propertyValue = newValue.Any() ? newValue.ToArray() : null;
            }
            // We generally want to randomize ILayerSource references, but we need to ensure
            // that we don't randomly generate one of the special-case forbidden sink types.
            else if (Validation_Enabled && IsProperty<Nested>(prop, p => p.sink))
            {
                // We have to make sure that forbidden layer sink types aren't used as the sink.
                HashSet<Type> typeRestrictions = TestSuite_Layer_Nested.UnsupportedNestedSinkTypes;
                // Furthermore, if sources have already been assigned to the current resource, we
                // cannot pick a sink that will cause one or more of those sources to become invalid.
                // TODO: Keep these checks in sync with those performed in GetLayerSourceRestrictions
                if (obj is Nested nestedLayer && (nestedLayer.sources?.Any() ?? false))
                {
                    // Sink can't be a BackAllocatedLayer if any sources are unsupported by it
                    HashSet<Type> problematicSourceTypes = TestSuite_Layer_BackAllocatedLayer.UnsupportedBackAllocatedLayerSinkTypes;
                    if (AnyLayerSourceMatchesCriteria(nestedLayer, source =>
                         problematicSourceTypes.Contains(GetLayerDefinition(source).GetType())))
                        typeRestrictions.Add(typeof(BackAllocatedLayer));
                    // Sink can't be a FixedDatePayment if any sources are Payment Patterns
                    problematicSourceTypes = new HashSet<Type>(TestSuite_Layer_Base.PaymentPatternTypes);
                    if (AnyLayerSourceMatchesCriteria(nestedLayer, source =>
                        problematicSourceTypes.Contains(GetLayerDefinition(source).GetType())))
                        typeRestrictions.Add(typeof(FixedDatePayment));
                }
                propertyValue = GenerateNestedLayerSourceReference(currentRecursion, typeRestrictions);
            }
            // Same restrictions as above, but handling a list of references
            else if (Validation_Enabled && prop.PropertyType == typeof(Nested.Sources) && obj is Nested nestedLayer)
            {
                // Consider generating fewer sources as we recurse deeper.
                int sourcesToGenerate = currentRecursion.Depth > Recursions_Before_Calming_Down ? 1 :
                    _random.Next(1, 1 + Recursions_Before_Calming_Down - currentRecursion.Depth);
                RecursionContext listRecursion = new RecursionContext(typeof(IReference<ILayerSource>), currentRecursion);
 
                // Determine if there are any type restrictions for the nested layer sources.
                // Generally, all layer types are allowed, but there's a GOTCHA - if the Nested layer sink
                // is a layer with source restrictions (like a BackAllocated layer), we need to account
                // for them in generating the nested sources, because these Nested.Sources will be converted
                // into sources of the sink layer at the AE - leading to issues on the server.
                HashSet<Type> typeRestrictions = nestedLayer.sink == null ? null :
                    GetLayerSourceRestrictions(new RecursionContext(nestedLayer.sink.ResourceType, currentRecursion));
 
                // Generate some source references
                IEnumerable<IReference<ILayerSource>> sources = Enumerable.Range(0, sourcesToGenerate)
                    .Select(_ => GenerateNestedLayerSourceReference(listRecursion, typeRestrictions));
                // Bug ARE-3553: Saved /layers/ endpoint requires the set of layer references to be unique
                if (LayerSourcesRequireLayerReference(listRecursion))
                    sources = sources.GroupBy(r => r.ref_id, (id, grp) => grp.First());
                propertyValue = new Nested.Sources(sources);
            }
            // Properties that accept layer/layer_view references have some special rules
            // Works for ValueAllocator.sink/target/group properties
            // Note: Nested.sink is handled separately above because it has a top-level type restriction.
            //       BackAllocatedLayer.sink is handled within because it has a restriction for all
            //       subsequent nested layers that exist within its tree.
            else if (Validation_Enabled && prop.PropertyType == typeof(IReference<ILayerSource>))
            {
                propertyValue = GenerateNestedLayerSourceReference(currentRecursion);
            }
            // If this is a BackAllocatedLayer, the source_id must be changed to match
            // the id of something in the new sink.
            else if (Validation_Enabled && IsProperty<BackAllocatedLayer>(prop, p => p.source_id))
            {
                propertyValue = PickBackAllocatedLayerSourceId(((BackAllocatedLayer)obj).sink);
            }
            // Build a random valid LayerView.layer object
            else if (Validation_Enabled && IsProperty<ILayerView>(prop, p => p.layer))
            {
                // Ensure the layer selected is valid with the analysis_profile
                propertyValue = TryGenerate(() =>
                        (ILayer)CreateRandomizedInstance(prop.PropertyType, currentRecursion),
                    // TODO: This should no longer be necessary, since resource generation routines
                    //       have all been refined to generate valid resources on-the-fly based on
                    //       the globally configured 'Target Analysis Profile'
                    tentative => ResourceIsValidForAnalysisProfile(tentative,
                        Resolve(((ILayerView)obj).analysis_profile)),
                    () => "The generated layer or one of its dependencies is not valid " +
                        "to use with the current analysis profile.", prop, recursionInfo: currentRecursion);
            }
            // Build a random PortfolioView.portfolio reference
            else if (Validation_Enabled && IsProperty<PortfolioView>(prop, p => p.portfolio))
            {
                PortfolioView source = (PortfolioView)obj;
                // If this PortfolioView has already specified layer_views, we
                // can't also specify a portfolio reference, so 50/50 chance of using each
                if ((source.layer_views?.Any() ?? false) && _random.Next(2) == 1)
                    propertyValue = null;
                else
                {
                    source.layer_views = null;
                    // Ensure the portfolio selected is valid with the analysis_profile
                    propertyValue = TryGenerate(() =>
                    {
                        IReference<StaticPortfolio> newValue = (IReference<StaticPortfolio>)
                            CreateRandomizedInstance(prop.PropertyType, currentRecursion);
                        StaticPortfolio tentative = Resolve(newValue).ShallowCopy();
                        int originalLayerCount = tentative.layers.Count;
                        // Modify the portfolio as necessary to ensure none of its layers
                        // reference invalid resources.
                        // TODO: This check should no longer be necessary
                        tentative.layers = new HashSet<IReference<ILayer>>(tentative.layers
                            .Where(layer => ResourceIsValidForAnalysisProfile(Resolve(layer),
                                Resolve(source.analysis_profile))));
                        // If we ended up removing one or more invalid layers, post the new portfolio
                        if (tentative.layers.Count != originalLayerCount)
                        {
                            currentRecursion.LogIndented("Warning: The StaticPortfolio generated randomly " +
                                "contained some layers that were not compatible with the source analysis " +
                                "profile. This should no longer be happening. As a workaround, the invalid " +
                                "layers have been removed.");
                            if (!tentative.layers.Any())
                                return null;
                            newValue = tentative.Post().ToReference();
                            CacheResource(newValue);
                        }
                        return newValue;
                    }, reference => reference != null, () =>
                        "The generated portfolio reference didn't contain " +
                        "any layers that are valid to use with the current analysis profile " +
                        "(due to its event catalog references).", prop, recursionInfo: currentRecursion);
                }
            }
            // OR Build a random list of PortfolioView.layer_views
            else if (Validation_Enabled && IsProperty<PortfolioView>(prop, p => p.layer_views))
            {
                PortfolioView source = (PortfolioView)obj;
                // If this PortfolioView has already specified a Portfolio reference, we
                // can't also specify layer_views, so 50/50 chance of using each
                if (source.portfolio != null && _random.Next(2) == 1)
                    propertyValue = null;
                else
                {
                    source.portfolio = null;
                    propertyValue = TryGenerate(
                        () => GeneratePortfolioViewLayerViews((PortfolioView)obj, currentRecursion),
                        set => set.Any(), () => "None of the generated layer_views' Layers " +
                            "were compatible with this PortfolioView's analysis profile.",
                        prop, recursionInfo: currentRecursion);
                }
            }
#pragma warning disable 618 //Continued support for testing obsolete classes
            // Random PortfolioLossSet.perspective must be 2 characters
            else if (Validation_Enabled && IsProperty<PortfolioLossSet>(prop, p => p.perspective))
            {
                propertyValue = Output.RandomString(2, 2, _random);
            }
            // Bug: ARE-6040 Using "LossNetOfAggregateTerms" on a NestedLayerLossSet will break the AE/SE
            else if (Validation_Enabled && IsProperty<NestedLayerLossSet>(prop, p => p.loss_type) &&
                obj is NestedLayerLossSet)
            {
                propertyValue = LossType.LossGross;
            }
#pragma warning restore 618
            // Random ParametricLossSet allows only certain distributions for each property
            else if (Validation_Enabled && (
                IsProperty<ParametricLossSet>(prop, p => p.frequency) ||
                IsProperty<ParametricLossSet>(prop, p => p.seasonality) ||
                IsProperty<ParametricLossSet>(prop, p => p.severity) ||
                IsProperty<QCLSLossSet>(prop, p => p.distribution)))
            {
                propertyValue = GenerateParametricLossSetDistributions(prop, currentRecursion);
            }
            // transform_records cannot include policies from the forward_records and vice-versa
            else if (IsProperty<Policy>(prop, p => p.transform_records))
            {
                HashSet<RecordType> existingForwardRecords =
                    (obj as Policy)?.forward_records ?? new HashSet<RecordType>();
                propertyValue = new HashSet<RecordType>(Enum<RecordType>.Values.Where(recordType =>
                    // Exclude RecordTypes already used. 50% chance to use all others.
                    !existingForwardRecords.Contains(recordType) && _random.Next(2) == 0));
            }
            else if (IsProperty<Policy>(prop, p => p.forward_records))
            {
                HashSet<RecordType> existingTransformRecords =
                    (obj as Policy)?.transform_records ?? new HashSet<RecordType>();
                propertyValue = new HashSet<RecordType>(Enum<RecordType>.Values.Where(recordType =>
                    // Exclude RecordTypes already used. 50% chance to use all others.
                    !existingTransformRecords.Contains(recordType) && _random.Next(2) == 0));
            }
            // A random selection of RecordTypes
            else if (IsProperty<RecordTypeAnyOfFilter>(prop, p => p.values))
            {
                RecordType[] allRecordTypes = Enum<RecordType>.Values.ToArray();
                propertyValue = allRecordTypes.OrderBy(x => _random.NextDouble())
                    .Take(_random.Next(1, allRecordTypes.Length)).ToList();
            }
            // Any random LossFilter.attribute must be derived from the event catalog
            else if (Validation_Enabled && IsProperty<AttributeFilter>(prop, l => l.attribute))
            {
                propertyValue = GenerateAttributeFilterAttribute((AttributeFilter)obj);
            }
            // Any random LossFilter.value must be derived from the event catalog and attribute
            else if (Validation_Enabled && (IsProperty<AnyOfFilter>(prop, p => p.values) ||
                IsProperty<ComparisonFilter>(prop, p => p.value)))
            {
                propertyValue = GenerateAttributeValue((AttributeFilter)obj, prop);
            }
            // Make sure RangeFilter.begin_value <= RangeFilter.end_value
            else if (Validation_Enabled && IsProperty<RangeFilter>(prop, o => o.end_value))
                propertyValue = ((RangeFilter)obj).begin_value +
                    _random.NextDouble() * (Max_Random - ((RangeFilter)obj).begin_value);
            else if (Validation_Enabled && IsProperty<RangeFilter>(prop, o => o.begin_value))
                propertyValue = Min_Random +
                    _random.NextDouble() * (((RangeFilter)obj).end_value - Min_Random);
            // Make sure lower <= upper
            else if (Validation_Enabled && IsProperty<UniformDistribution>(prop, o => o.upper))
                propertyValue = ((UniformDistribution)obj).lower +
                    _random.NextDouble() * (Max_Random - ((UniformDistribution)obj).lower);
            else if (Validation_Enabled && IsProperty<UniformDistribution>(prop, o => o.lower))
                propertyValue = Min_Random +
                    _random.NextDouble() * (((UniformDistribution)obj).upper - Min_Random);
            // Also keep Discrete distribution max/mean values small, because these are used as
            // frequency distributions and large values lead to simulations that take too long.
            else if (Validation_Enabled && IsProperty<UniformIntDistribution>(prop, o => o.upper))
                propertyValue = _random.Next(((UniformIntDistribution)obj).lower + 1, 50);
            else if (Validation_Enabled && IsProperty<UniformIntDistribution>(prop, o => o.lower))
                propertyValue = _random.Next(0, Math.Max(1, ((UniformIntDistribution)obj).upper - 1));
            else if (Validation_Enabled && IsProperty<BinomialDistribution>(prop, d => d.n))
                propertyValue = _random.Next(0, 50);
            else if (Validation_Enabled && (
                IsProperty<DiracDistribution>(prop, d => d.value) ||
                IsProperty<NegativeBinomialDistribution>(prop, d => d.r) ||
                IsProperty<PoissonDistribution>(prop, d => d.mean)))
            {
                propertyValue = _random.NextDouble() * 50;
            }
            // Modulo is relatively rare in distributions and its presence messes up profiles,
            // so increase the chance of generating no modulo.
            else if (Validation_Enabled && IsProperty<Distribution>(prop, d => d.modulo))
                propertyValue = _random.Next(0, 3) < 2 ? (double?)null : _random.NextDouble() * 100;
            // Make sure inception date <= expiry date
            else if (Validation_Enabled && IsProperty<ILayer_WithTerms>(prop, l => l.inception_date))
            {
                // If expiry date is set, pick some random time before expiration, else, a random time
                propertyValue = ((ILayer_WithTerms)obj).expiry_date?.AddDays(_random.Next(-365, 0)) ??
                    CreateRandomizedInstance(prop.PropertyType, currentRecursion);
            }
            else if (Validation_Enabled && IsProperty<ILayer_WithTerms>(prop, l => l.expiry_date))
            {
                // If inception date is set, pick some random time after inception, else, a random time
                propertyValue = ((ILayer_WithTerms)obj).inception_date?.AddDays(_random.Next(1, 366)) ??
                    CreateRandomizedInstance(prop.PropertyType, currentRecursion);
            }
            else if (Validation_Enabled && IsProperty<ILayer_WithTerms>(prop, o => o.fees))
            {
                // TODO: Fix the Fees object model so that it's compile-time typed, not just a list
                //       of strings, and then we can remove this and it will randomly generate correctly.
                propertyValue = _random.Next(2) == 0 ? null : _random.Next(2) == 0 ?
                    Samples.Fees.ListOfAllFeeTypes : Samples.Fees.ListWithNestedFeeReference;
            }
            // Ensure no referenced loss sets have an invalid event catalog.
            else if (Validation_Enabled && IsProperty<ILayer_WithLossSets>(prop, l => l.loss_sets))
            {
                // Ensure the loss sets selected are valid with the analysis_profile
                propertyValue = TryGenerate(() =>
                    {
                        List<IReference<LossSet>> generated =
                            CreateRandomizedInstance<List<IReference<LossSet>>>(currentRecursion);
                        // Skip loss sets that reference resources not compatible with the analysis profile
                        // TODO: This check should no longer be necessary
                        int originalCount = generated.Count;
                        generated = generated.Where(ls =>
                            ResourceIsValidForAnalysisProfile(Resolve(ls), Target_AnalysisProfile)).ToList();
                        if (generated.Count != originalCount)
                            currentRecursion.LogIndented("Warning: The loss_sets list generated randomly " +
                                "contained some that were not compatible with the target analysis profile." +
                                "This should no longer be happening. As a workaround, the invalid " +
                                "loss sets have been removed.");
                        return generated;
                    },
                    result => result.Count > 0, () => "All of the referenced loss sets " +
                        "referenced an event catalog not in the analysis profile.",
                    prop, recursionInfo: currentRecursion);
            }
            // TODO: Cannot randomize optimization parameters much right now as they are too constrained
            else if (IsProperty<OptimizationView>(prop, o => o.custom_parameters))
            {
                // But we can only really randomize the "Discretization" without impacting things
                Dictionary<string, object> customParameters = _samples.OptimizationView_CustomParameters;
                // ARE-6274: Discretization cannot be bigger than the smallest difference between min and max among
                //           domain layers. This is why we keep it below 0.01 here, and keep the difference between
                //           min and max above 0.1 in GenerateOptimizationViewDomains
                customParameters["Discretization"] = _random.NextDouble() / 100;
                propertyValue = customParameters;
            }
            // Generate a random population_size
            else if (IsProperty<OptimizationView>(prop, o => o.population_size))
            {
                // Population Size is currently [1,10000] but we don't want to kick off a huge run, so limit to 100
                // More than 2, because population sizes of 1 have been linked to issues like ARE-4575
                propertyValue = _random.Next(2, 101);
            }
            // Generate a random iterations
            else if (IsProperty<OptimizationView>(prop, o => o.iterations))
            {
                // Iterations is currently [1,10000] but we don't want to kick off a huge run, so limit to 100
                propertyValue = _random.Next(2, 101);
            }
            // Generate random domains layers
            else if (IsProperty<OptimizationView>(prop, o => o.domains))
            {
                propertyValue = TryGenerate(
                    () => GenerateOptimizationViewDomains((OptimizationView)obj, currentRecursion),
                    domains => domains.Any(), () => "None of the domain's Layers generated " +
                        "were compatible with this OptimizationView's analysis profile.",
                    prop, recursionInfo: currentRecursion);
            }
            // ExchangeRateProfile rate_selection_order should always at least end with a 'Latest'
            // rule to ensure a rate can always be found for valid currencies.
            else if (IsProperty<ExchangeRateProfile>(prop, p => p.rate_selection_order))
            {
                object value = CreateRandomizedInstance(prop.PropertyType, currentRecursion);
                ((List<ExchangeRateSelectionRule>)value).Add(new ExchangeRateLatestRule());
                propertyValue = value;
            }
            // ExchangeRateProfile monetary_unit_overrides can only contain "Date" and/or "Rate"
            else if (IsProperty<ExchangeRateSelectionRule>(prop, o => o.monetary_unit_overrides))
            {
                List<string> monetary_unit_overrides = new List<string>();
                if (_random.Next(2) == 1) monetary_unit_overrides.Add("Date");
                if (_random.Next(2) == 1) monetary_unit_overrides.Add("Rate");
                propertyValue = monetary_unit_overrides;
            }
            // Take advantage of the description property to store some debugging info
            else if (IsProperty<IStoredAPIResource>(prop, p => p.description))
            {
#if DEBUG
                #if MSTEST
                // In debug mode, we can get the method name from our stack to tell us what test produced this resource.
                List<MethodBase> methodStack = new StackTrace(false).GetFrames()?.Select(stackFrame => stackFrame.GetMethod()).ToList();
                MethodBase topOfStack = methodStack?.Where(m => m.GetCustomAttributes(typeof(TestMethodAttribute), false)
                   .Any()).FirstOrDefault() ?? methodStack?.Last();
                string testName = topOfStack == null ? "Unknown" : $"{topOfStack.ReflectedType?.NiceTypeName()}.{topOfStack.Name}";
                #elif NUNIT
                string testName = "Unknown";
                #endif
                propertyValue = $"Randomly Generated {obj.GetType().NiceTypeName()} for test: \"{testName}\". {Output.RandomString(1, 10, _random)}";
#else
                propertyValue = $"Randomly Generated {obj.GetType().NiceTypeName()}. {Output.RandomString(1, 10, _random)}";
#endif
            }
            // If the property is nullable and has no NotNull constraint,
            // have a 50% chance to set the value to null.
            else if ((!prop.PropertyType.IsValueType || Nullable.GetUnderlyingType(prop.PropertyType) != null) &&
                !prop.IsAttributeDefinedFast<NotNullAttribute>() && _random.Next(2) == 0)
                propertyValue = null;
            // If the property specifies numeric bounds, generate a number within its bounds.
            else if (prop.IsAttributeDefinedFast<LessThanAttribute>() ||
                prop.IsAttributeDefinedFast<GreaterThanAttribute>())
            {
                Type underlyingType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType;
                LessThanAttribute lt = prop.GetCustomAttributeFast<LessThanAttribute>();
                GreaterThanAttribute gt = prop.GetCustomAttributeFast<GreaterThanAttribute>();
                double interval = underlyingType.IsIntegerType() ? 1.0 : 0.01;
                // The minimum/maximum to generate is the most restrictive of the
                // globally configured minimum/maximum random number, and
                // the minimum allowed by the `GreaterThanAttribute`/`LessThanAttribute`
                double minimum = gt == null ? Min_Random : Math.Max(Min_Random,
                    gt.CanEqual ? gt.GreaterThanValue : gt.GreaterThanValue + interval);
                double maximum = lt == null ? Max_Random : Math.Min(Max_Random,
                    lt.CanEqual ? lt.LessThanValue : lt.LessThanValue - interval);
                if (underlyingType.IsIntegerType())
                {
                    // Get the minimum value allowed by the type (e.g. 0 for unsigned types)
                    // Constrain the "minimum" value further if necessary.
                    long minSupported = Convert.ToInt64(underlyingType.GetField("MinValue").GetValue(null));
                    int minInt = (int)Math.Max((long)minimum, minSupported);
                    int randomInt = _random.Next(minInt, (int)maximum + 1); // +1 because max is exclusive.
                    propertyValue = Convert.ChangeType(randomInt, underlyingType);
                }
                else
                {
                    double random = _random.NextDouble() * (maximum - minimum) + minimum;
                    propertyValue = underlyingType == typeof(MonetaryUnit) ?
                        new MonetaryUnit(random, GetRandomCurrency()) :
                        Convert.ChangeType(random, underlyingType);
                }
            }
            // Any other property can use the default random generation behaviour for its type.
            else
            {
                object value = CreateRandomizedInstance(prop.PropertyType, currentRecursion);
                propertyValue = value;
            }
 
            // Now that the property has been given a value, check whether the generated
            // value violates any custom attributes. If so, this resource cannot be POSTed
            // so we may as well return a null object entirely (and log the issue).
            // We only expect this to happen as we get close to our maximum recursion level,
            // which constrains our ability to generate resources for required properties.
            if (Validation_Enabled)
            {
                IEnumerable<ValidationAttribute> invalidAttributes = ((IEnumerable<ValidationAttribute>)
                    Attribute.GetCustomAttributes(prop, typeof(ValidationAttribute), true))
                    .Where(validationAttribute => !validationAttribute.IsValid(propertyValue));
                if (invalidAttributes.Any())
                {
                    throw new PropertyGenerationException("Failed to correctly generate property " +
                        $"\'{prop.Name}\' for new {obj.GetType().NiceTypeName()}. Value of " +
                        $"{Output.AutoFormat(propertyValue)} did not meet criteria of the " +
                        $"validation attributes: {Output.AutoFormat(invalidAttributes)}.");
                }
            }
 
            return propertyValue;
        }
 
        public object ChangePropertyValueRandomly(IAPIType obj, PropertyInfo prop,
            int max_attempts = Max_ReRandomize_Attempts, RecursionContext parentRecursionInfo = null)
        {
            object newValue = null;
            object currentValue = prop.GetValue(obj, null);
            RecursionContext currentRecursion = new RecursionContext(obj.GetType(), parentRecursionInfo);
            string propertyDescription = $"the {prop.ReflectedType.NiceTypeName()} property " +
                $"{prop.PropertyType.NiceTypeName()} \'{prop.DeclaringType.NiceTypeName()}.{prop.Name}\'";
 
            // A couple of quick rules we can apply since we know our goal is to *change* the value.
            // If the property is a boolean, no need for fanfare, the decision is obvious
            if (prop.PropertyType == typeof(bool))
                newValue = !(bool)prop.GetValue(obj);
            // Special case properties. Some properties cannot be randomized normally.
            else if (Validation_Enabled)
            {
                // Do a sanity check - if the resource has an analysis profile that conflicts with
                // the current reflection instance's configuration, many generated property values
                // will end up being invalid.
                if (obj is IAPIAnalysis analysis && analysis.analysis_profile.ref_id != Target_AnalysisProfile.id)
                {
                    if (IsProperty<IAPIAnalysis>(prop, r => r.analysis_profile))
                        newValue = Target_AnalysisProfile.ToReference();
                    else
                        throw new PropertyGenerationException("Cannot randomly modify properties in a valid way for " +
                            $"an analysis whose analysis profile ({analysis.analysis_profile.ref_id}) does not match " +
                            $"the current configured Reflection.Target_AnalysisProfile ({Target_AnalysisProfile.id}).");
                }
                // Data file properties usually need special handling.
                else if (IsProperty<IAPIResource_WithDataEndpoint>(prop, s => s.data_file))
                {
                    // If a data file was given, post a duplicate to get a new one that's guaranteed valid.
                    if (currentValue != null)
                        newValue = PostCopy((IReference<DataFile>)currentValue);
                    // Otherwise, grab the datafile from the matching sample.
                    // Special case - if looking for a YLT/YELT loss set, we must select the sample data
                    // that matches the configuration (csv/binary and without reinstatements if gross)
                    // Keep in mind that if the loss_type
                    else if (obj is YELTLossSet yelt && LossType.LossGross ==
                        (yelt.loss_type ?? LossSet.LossTypeDefault.GetDefaultLossTypeForLossSet(yelt)))
                        newValue = _samples.LossSet_YELTLossSet.Posted.data_file;
                    else if (obj is YLTLossSet ylt && LossType.LossGross ==
                        (ylt.loss_type ?? LossSet.LossTypeDefault.GetDefaultLossTypeForLossSet(ylt)))
                        newValue = _samples.LossSet_YLTLossSet.Posted.data_file;
#pragma warning disable 618
                    else if (obj is YELTLossSet yeltMaybeBinary && yeltMaybeBinary.data_type == YELTLossSet.DataType.binary)
                        throw new PropertyGenerationException("Cannot assign a random new data_file property " +
                            "to a binary YELT because there is no sample resource with this type of data.");
#pragma warning restore 618
                    // Other files we can use reflection to grab the data of any sample of the same type
                    else
                    {
                        newValue = (Resolve(GetSampleOfType(obj.GetType()))
                                as IAPIResource_WithDataEndpoint)?.data_file ??
                            throw new PropertyGenerationException("No sample resources found of type " +
                                $"{obj.GetType()} with a {prop.DeclaringType}.data_file to reuse.");
                    }
                }
                // Special Case: Analysis profiles are sensitive. In some situations, we cannot
                // modify them without invalidating one or more other properties of the same resource.
                else if (IsProperty<ILayerView>(prop, r => r.analysis_profile) &&
                    AnyLayerSourceMatchesCriteria((ILayerView)obj, layerSource => layerSource is ILayerView))
                    throw new PropertyGenerationException("Cannot change just the analysis_profile " +
                        "of this layer_view because it contains nested references to other layer_views " +
                        "whose analysis_profiles would have to be changed as well to match.");
                // PortfolioViews have several properties that cannot be changed without side effects
                else if (IsProperty<PortfolioView>(prop, r => r.layer_views) && ((PortfolioView)obj).portfolio != null)
                    throw new PropertyGenerationException("Cannot give a PortfolioView layer_views " +
                        "without setting it's portfolio reference to null first.");
                else if (IsProperty<PortfolioView>(prop, r => r.portfolio) && ((PortfolioView)obj).layer_views != null)
                    throw new PropertyGenerationException("Cannot give a PortfolioView a portfolio " +
                        "without setting it's layer_views collection to null first.");
                else if (IsProperty<PortfolioView>(prop, r => r.analysis_profile) && ((PortfolioView)obj).layer_views != null)
                    throw new PropertyGenerationException("Cannot change just the analysis_profile of a " +
                        "PortfolioView without changing all its layer_views to match the new analysis_profile.");
                // Otherwise, if the property being changed is analysis_profile, we still need to
                // generate a new analysis profile with the same event catalogs and loss filters,
                // or it might not be valid against the target resource in many other ways.
                else if (IsProperty<IAPIAnalysis>(prop, v => v.analysis_profile))
                {
                    // Just post a new analysis profile with all the same information
                    currentRecursion.LogIndented($"Special case {propertyDescription} - " +
                        "creating a duplicate analysis profile via re-post.");
                    newValue = PostCopy((IReference<AnalysisProfile>)currentValue);
                }
                // Analysis profile catalog must match it's simulation catalog.
                else if (IsProperty<AnalysisProfile>(prop, r => r.event_catalogs))
                    throw new PropertyGenerationException("Cannot change just the event_catalog of an " +
                        "AnalysisProfile without changing it's simulation to match.");
                else if (IsProperty<StaticSimulation>(prop, r => r.event_catalogs) ||
                    IsProperty<ILossSet_WithEventCatalog>(prop, r => r.event_catalogs))
                    throw new PropertyGenerationException($"Cannot change the event_catalog of a {prop.ReflectedType} " +
                        "when validation is enabled, or it becomes invalid to use with this analysis profile.");
                // Bug: ARE-3963 optimizations have no currency flexibility.
                else if (IsProperty<OptimizationView>(prop, r => r.target_currency))
                    throw new PropertyGenerationException("Cannot change just the target_currency of an " +
                        "OptimizationView without changing all its domain layers to match the currency.");
                else if (IsProperty<ILossSet_Simulated>(prop, p => p.loss_type) && obj is ILossSet_Simulated simulatedLossSet &&
                    simulatedLossSet.loss_type == LossType.LossNetOfAggregateTerms && simulatedLossSet.data_file != null)
                    throw new PropertyGenerationException("Cannot just change the loss_type property of a simulated " +
                        "\"LossNetOfAggregateTerms\" loss set with an assigned data file, " +
                        "because its data_file may contain reinstatement information.");
#pragma warning disable 618
                // Bug: ARE-6040 Cannot use "LossNetOfAggregateTerms" on a NestedLayerLossSet
                else if (IsProperty<NestedLayerLossSet>(prop, p => p.loss_type) &&
                    obj is NestedLayerLossSet nlls && nlls.loss_type == LossType.LossGross)
                    throw new PropertyGenerationException("Cannot change the loss_type property " +
                        "because \"LossGross\" is the only acceptable value for NestedLayerLossSets.");
                else if (IsProperty<YELTLossSet>(prop, p => p.data_type) && obj is YELTLossSet yelt && yelt.data_file != null)
                    throw new PropertyGenerationException("Cannot change the data_type property of a YELTLossSet " +
                        "with an assigned data file, because its data_file likely will not match the new data_type.");
#pragma warning restore 618
                else if (IsProperty<AttributeFilter>(prop, f => f.attribute))
                    throw new PropertyGenerationException("Cannot change just the attribute of an " +
                        "AttributeFilter without risking changing the type of values that are valid.");
                // Some resources can barly be modified at all
                else if (obj is Function && !IsProperty<Function>(prop, r => r.name))
                    throw new PropertyGenerationException("Cannot change any Optimization.Function property without also " +
                        "changing its name - because the server requires each Optimization.Function to have a unique name.");
                // Easiest way to make a new valid BackAllocatedLayer.sink without invalidating
                // the current source_id is wrap the old sink in a nested layer
                else if (IsProperty<BackAllocatedLayer>(prop, p => p.sink))
                    newValue = CacheResource(new Nested
                    {
                        sink = _samples.Layer_QuotaShare.AsReference,
                        sources = new Nested.Sources(((BackAllocatedLayer)obj).sink)
                    }.Post());
                // Easiest way to change FixedDatePayment.payments without risking having an
                // insufficient payment dates is to replace with the same number of payments.
                else if (obj is FixedDatePayment fdp && IsProperty<FixedDatePayment>(prop, p => p.payments))
                    newValue = fdp.payments.Select(_ => _random.NextDouble()).ToList();
            }
            // If any of the above rules determined the required new property value, return now.
            if (newValue != null)
            {
                currentRecursion.LogIndented($"A \"quick rule\" was used to change {propertyDescription} " +
                    $"on an instance of type {obj.GetType().NiceTypeName()} from a value of " +
                    $"{Output.AutoFormat(currentValue)} to a value of {Output.AutoFormat(newValue)}");
                prop.SetValue(obj, newValue);
                return newValue;
            }
 
            string last_error = null;
            string GenerateFinalError(string errMessage, object duplicateValue) =>
                errMessage != null ? $"RandomizePropertyValue method failed: {errMessage}" :
                    $"The new value generated is equal to the original value ({duplicateValue})";
            try
            {
                newValue = LimitAttempts(() =>
                    {
                        last_error = null;
                        // Suppress errors generating properties and retry
                        try { return RandomizePropertyValue(obj, prop, currentRecursion); }
                        catch (PropertyGenerationException ex)
                        {
                            last_error = ex.Message;
                            return ex;
                        }
                    },
                    // Hack: If we accidentally generated the same value this property already had
                    // (worse case 50% chance on e.g. a Boolean property with only 2 valid values),
                    // we retry up to 'max_attempts' times. If configured to retry up to 20 times,
                    // this gives a 1/2^20 (0.0001%) chance of failing completely at random.
                    // If this happens, be suspicious that the RandomizePropertyValue function has
                    // fallen into a situation where it is only capable of generating a single value
                    // for the resource & property in question (which is not very 'random').
                    tentative => IsPropertyValueChanged(currentValue, tentative),
                    () => GenerateFinalError(last_error, currentValue),
                    prop, max_attempts, recursionInfo: currentRecursion);
            }
            catch (PropertyGenerationException)
            {
                // Property Generation should be relatively trivial if Validation is disabled.
                if (!Validation_Enabled) throw;
                // If the original is a stored resource, simply re-posting it should yield a valid duplicate.
                if (currentValue is IStoredAPIResource copiable)
                    newValue = PostCopy(copiable);
                else if (currentValue is IReference<IStoredAPIResource> copyableReference)
                    newValue = PostCopy(copyableReference);
                // If the original is a list with more than one item, we can simply
                // remove an item from the list to change its value to a new list.
                else if (currentValue is IList asList && asList.Count > 2)
                {
                    IList newList = (IList)Activator.CreateInstance(asList.GetType());
                    asList.Cast<object>().Skip(1).ToList().ForEach(o => newList.Add(o));
                    newValue = newList;
                }
                // If it is a list of IStoredAPIResource references, we can try copying it
                else if (currentValue is IList &&
                    currentValue is IEnumerable<IReference<IStoredAPIResource>> copyableList)
                {
                    IList newList = (IList)Activator.CreateInstance(currentValue.GetType());
                    newList.Add(PostCopy(copyableList.First()));
                    newValue = newList;
                }
                // Re-raise the exception if we couldn't find a fall-back way of generating a value.
                if (newValue == null)
                    throw;
                currentRecursion.LogIndented("Found a fallback rule for modifying the property " +
                    "since random generation failed.");
            }
 
            // If successful, log the changed property and return.
            currentRecursion.LogIndented($"Changing {propertyDescription} on " +
                $"an instance of type {obj.GetType().NiceTypeName()} from a value of " +
                $"{Output.AutoFormat(currentValue)} to a value of {Output.AutoFormat(newValue)}");
            prop.SetValue(obj, newValue);
            return newValue;
        }
 
        private static bool IsPropertyValueChanged(object originalValue, object newValue)
        {
            // Retry if an invalid property value was generated.
            if (newValue is PropertyGenerationException)
                return false;
            // Test reference equality and simple equivalence before attempting
            // the more expensive sequence equality.
            if (ReferenceEquals(originalValue, newValue) || Equals(originalValue, newValue))
                return false;
            // If the value is an enumerable (other than a string) - test each element
            // Note: We must use "Cast" here to create two comparable sequences, in case these
            //       are IEnumerables of ValueTypes, because ValueTypes must be explicitly boxed.
            if (!(newValue is string) && newValue is IEnumerable enum1 && originalValue is IEnumerable enum2)
                return !enum1.Cast<object>().SequenceEqual(enum2.Cast<object>());
            // Otherwise, test for equivalence using the default "Equals" implementation.
            return true;
        }
 
        private IReference<IStoredAPIResource> PostCopy(IReference<IStoredAPIResource> reference) =>
            PostCopy(Resolve(reference)).ToReference(true);
 
        private IStoredAPIResource PostCopy(IStoredAPIResource resource)
        {
            if (!Validation_Enabled)
                throw new Exception("PostCopy should not be used when reflection class " +
                    "is configured for offline resource generation.");
            IStoredAPIResource copy = resource.Post();
            if (copy is IStoredAPIResource_WithStatus pollable)
                copy = pollable.PollUntilReady(Samples.DataPollingOptions);
            CacheResource(copy);
            Console.WriteLine($"Created a copy of {resource.GetType().NiceTypeName()} {resource.id} " +
                $"with new id {copy.id}");
            return copy;
        }
 
        #region Specific Property Generation Helper Routines
        private bool LayerSourcesRequireLayerReference(RecursionContext recursionInfo) =>
            // Only layer_view.layer definitions may contain inlined layers or layer_view references.
            !recursionInfo.MatchesCondition(r => typeof(ILayerView).IsAssignableFrom(r.Type)) ||
            // If this source is being generated for a layer refence (even if that layer reference is
            // being included in a layer_view higher up) - only other layer references are supported.
            recursionInfo.MatchesCondition(r => typeof(IReference<ILayer>).IsAssignableFrom(r.Type));
 
        private static HashSet<Type> GetLayerSourceRestrictions(RecursionContext recursionInfo)
        {
            HashSet<Type> excludedLayerTypes = new HashSet<Type>();
            // ARE-7212: If we are inside a BackAllocatedLayer structure, we are forbidden from using
            // PaymentPatterns anywhere between the "sink" and "source_id". Since we have no way of
            // determining whether we are past the "source_id" (if it has even been randomly assigned yet)
            // the only safe thing to do is not allow any PaymentPatterns within the BackAllocated structure.
            if (recursionInfo.MatchesCondition(r => r.Type == typeof(BackAllocatedLayer)))
                TestSuite_Layer_BackAllocatedLayer.UnsupportedBackAllocatedLayerSinkTypes.ToList()
                    .ForEach(t => excludedLayerTypes.Add(t));
 
            // No-Issue: If we are inside a FixedDatePayment structure, we cannot risk embedding any other
            // FixedDatePayment or DelayedPayment structures within it (even though these are supported).
            // This is because the "payment_dates" are extremely strict, and must include dates beyond the
            // latest loss generated. There's no way to ensure that inner PaymentPatterns can generate
            // valid attributes for themselves while simultaneously guaranteeing that they won't produce occurrences
            // later than the latest "payment_dates" of the outer FixedDatePayment. So don't even try.
            if (recursionInfo.MatchesCondition(r => r.Type == typeof(FixedDatePayment)))
                TestSuite_Layer_Base.PaymentPatternTypes.ToList().ForEach(t => excludedLayerTypes.Add(t));
            return excludedLayerTypes;
        }
 
        private IReference<ILayerSource> GenerateNestedLayerSourceReference(
            RecursionContext recursionInfo, IEnumerable<Type> excludedLayerTypes = null)
        {
            // The three types of ILayerSource references that might be generated
            Type inlinedLayer = typeof(ILayer);
            Type layerReference = typeof(IReference<ILayer>);
            Type layerViewReference = typeof(IReference<ILayerView>);
 
            HashSet<Type> typeExclusions = GetLayerSourceRestrictions(recursionInfo);
            excludedLayerTypes?.ToList().ForEach(t => typeExclusions.Add(t));
 
            // If there are any restrictions, immediately pick a valid instantiable type
            if (typeExclusions.Any())
            {
                // Choose one of the remaining valid types to generate below
                inlinedLayer = GetAllInstantiableSubtypes(inlinedLayer)
                    .Except(typeExclusions).OrderBy(t => _random.NextDouble()).First();
                layerReference = GetAllInstantiableSubtypes(layerReference).Where(t => /* t is some IReference<TLayer> */
                    !typeExclusions.Contains(t.GetGenericArguments()[0])).OrderBy(t => _random.NextDouble()).First();
                layerViewReference = GetAllInstantiableSubtypes(layerViewReference).Where(t => /* t is some IReference<ILayerView<TLayer>> */
                    !typeExclusions.Contains(t.GetGenericArguments()[0].GetGenericArguments()[0]))
                    .OrderBy(t => _random.NextDouble()).First();
                // Note: It is still possible that one of the above layers could house a NestedLayerLossSet
                // whose layer reference (not generated by this routine) could be a PaymentPattern. But we have stopped
                // randomly generating NestedLayerLossSets, so this shouldn't have to be monitored anymore.
            }
 
            int roll = _random.Next(5);
            if (roll == 0 || LayerSourcesRequireLayerReference(recursionInfo))
                return (IReference<ILayer>)CreateRandomizedInstance(layerReference, recursionInfo);
            // Chance to generate a layer_view reference
            if (roll == 1)
                return (IReference<ILayerView>)CreateRandomizedInstance(layerViewReference, recursionInfo);
            // Chance to generate an inlined layer reference (random number generator is set to make
            // this the most likely case - because it can be done client-side, so it's quicker)
            return ((ILayer)CreateRandomizedInstance(inlinedLayer, recursionInfo))?
                .Change(l => l.id, null).ToReference();
        }
 
        private HashSet<IReference<ILayerView>> GeneratePortfolioViewLayerViews(
            PortfolioView owner, RecursionContext recursionInfo)
        {
            HashSet<IReference<ILayerView>> newlist = new HashSet<IReference<ILayerView>>();
            // First, randomize the layer_views collection, but then make changes to meet
            // constraints on PortfolioViews.
            HashSet<IReference<ILayerView>> random = (HashSet<IReference<ILayerView>>)
                CreateRandomizedInstance(newlist.GetType(), recursionInfo);
            if (!Validation_Enabled) return random;
            foreach (IReference<ILayerView> lv in random)
            {
                ILayerView temp = Resolve(lv);
                bool modified = false;
 
                // All layerViews must have the same analysis profile as this portfolio view.
                if (temp.analysis_profile.ref_id != owner.analysis_profile.ref_id)
                {
                    temp.analysis_profile = owner.analysis_profile;
                    modified = true;
                }
                // If the layerView references an invalid resource, we have to drop it
                // TODO: This check should no longer be necessary
                if (Validation_Enabled & !ResourceIsValidForAnalysisProfile(temp.layer, Resolve(temp.analysis_profile)))
                {
                    recursionInfo.LogIndented("Warning: The generated PortfolioView.layer_views list " +
                        "contained a randomly generated layer that was not compabile with the " +
                        "target analysis profile. This should no longer be happening. " +
                        "As a workaround, the invalid layer has been removed: " + temp.layer.Serialize());
                    continue;
                }
 
                IReference<ILayerView> toAdd;
                // If the analysis profile of the generated layer_view was changed, post the new one.
                if (modified)
                {
                    toAdd = temp.Post().ToReference(true);
                    CacheResource(toAdd);
                }
                else
                    toAdd = temp.ToReference();
 
                newlist.Add(toAdd);
            }
            return newlist;
        }
 
        private List<DomainEntry> GenerateOptimizationViewDomains(
            OptimizationView owner, RecursionContext recursionInfo)
        {
            List<DomainEntry> result = new List<DomainEntry>();
            // Curate the list of random layer types to choose from before generating domains.
            Type[] supportedTypes = GetAllInstantiableSubtypes(typeof(IReference<ILayer>)).ToArray();
            if (Validation_Enabled)
                supportedTypes = supportedTypes.Where(layerRefType =>
                    !TestSuite_OptimizationView.UnsupportedOptimizationLayerTypes.Contains(
                        layerRefType.GetGenericArguments()[0])).ToArray();
 
            // Generate between 1 and 5 layers to use as domain entries for the list:
            IEnumerable<IReference<ILayer>> layers = Enumerable.Range(1, 1 + _random.Next(5))
                .Select(i => (IReference<ILayer>)CreateRandomizedInstance(
                    supportedTypes[_random.Next(supportedTypes.Length)], recursionInfo));
            string currency = owner.target_currency;
            if (Validation_Enabled)
            {
                // Discard any layers found to reference resources not compatible with the analysis profile
                // TODO: This check should no longer be necessary
                layers = layers.Where(layer => ResourceIsValidForAnalysisProfile(
                    Resolve(layer), Resolve(owner.analysis_profile)));
                // If the target currency isn't set, we may need to derive it to create valid domains
                currency = currency ?? TargetCurrencyDefault.GetDefaultTargetCurrency(owner);
            }
 
            // Add all acceptable layers to the domains for this OptimizationView
            foreach (IReference<ILayer> layer_ref in layers)
            {
                IReference<ILayer> domainReference = layer_ref;
                if (Validation_Enabled)
                {
                    // Bug: Due to limitation ARE-3963 optimizations don't support layers with different currencies.
                    ILayer currentLayer = Resolve(layer_ref);
                    bool layerModified = false;
                    foreach (PropertyInfo monetaryProperty in currentLayer.GetType().GetPublicProperties_Fast()
                        .Where(p => p.PropertyType == typeof(MonetaryUnit)))
                    {
                        MonetaryUnit monetaryUnit = (MonetaryUnit)monetaryProperty.GetValue(currentLayer);
                        // Handle Bug ARE-5058 while we're here - OE can't handle null monetary units (like premium)
                        if (monetaryUnit == null)
                            monetaryProperty.SetValue(currentLayer, new MonetaryUnit(0, currency));
                        else if (monetaryUnit.currency != currency)
                            monetaryUnit.currency = currency;
                        else
                            continue;
                        layerModified = true;
                    }
 
                    // Bug ARE-7228: Optimization Engine crashes when layer has a null description!
                    if (currentLayer.description == null)
                    {
                        currentLayer.description = "Required for Optimization";
                        layerModified = true;
                    }
 
                    // If we had to change any of the currencies of the terms of the layer, post the changes
                    if (layerModified)
                    {
                        currentLayer = currentLayer.Post();
                        domainReference = currentLayer.ToReference(true);
                        CacheResource(domainReference);
                    }
                }
 
                // Create a new DomainEntry from this layer
                DomainEntry newDomainEntry = new DomainEntry
                {
                    layer = domainReference,
                    // min can be anything, but this is good enough
                    min = _random.Next(-2000, 2000) / 1000d,
                };
                // Max must be >= min. Have a 10% chance to set it equal min (locked)
                newDomainEntry.max = _random.Next(10) == 0 ? newDomainEntry.min :
                    // Otherwise, pick a random number greater than min.
                    // ARE-6274: Ensure Max is at least 0.1 greater than min, so that we have room
                    //           To randomize the discretization value.
                    _random.Next((int)(newDomainEntry.min * 1000), 2000) / 1000d + 0.1;
                result.Add(newDomainEntry);
            }
            return result;
        }
 
        private string GenerateAttributeFilterAttribute(AttributeFilter owner)
        {
            const int forbiddenColumns = 2;
            string csv = Samples.CSV.Event_Catalog_Data.Replace("\"", "").Replace("\r", "");
            int firstLineBreak = csv.IndexOf('\n');
            string[] headers = csv.Substring(0, firstLineBreak).Split(',').ToList()
                                  .Skip(forbiddenColumns).ToArray();
            // If this is a range filter, we need to restrict headers to numeric fields
            if (Validation_Enabled && (owner is ComparisonFilter || owner is RangeFilter))
            {
                string[] values = csv.Substring(firstLineBreak + 1,
                    csv.IndexOf('\n', firstLineBreak + 1) - firstLineBreak - 1).Split(',');
                headers = headers.Select((s, i) => new { s, i })
                    .Where(t => Double.TryParse(values[t.i + forbiddenColumns], out double _))
                    .Select(t => t.s).ToArray();
                if (headers.Length == 0)
                    Assert.Fail("Reflection-based LossFilter generation error: Could not find " +
                        "a numeric column for making a filter of type " + owner.GetType().NiceTypeName());
            }
            return headers[_random.Next(headers.Length)];
        }
 
        public object GenerateAttributeValue(AttributeFilter owner, PropertyInfo prop)
        {
            // Parse the event catalog that will be associated with this loss filter
            string csv = Samples.CSV.Event_Catalog_Data.Replace("\"", "").Replace("\r", "");
            string[] headers = csv.Substring(0, csv.IndexOf('\n')).Split(',');
            // Grab a random column from the actual event catalog to filter on
            int? index = headers.Select((s, i) => new { s, i }).Where(t => t.s.Equals(
                (string)typeof(AttributeFilter).GetProperty(nameof(AttributeFilter.attribute))
                .GetValue(owner, null), StringComparison.OrdinalIgnoreCase))
                .Select(t => (int?)t.i).FirstOrDefault();
            if (!index.HasValue)
                Assert.Fail("Reflection-based LossFilter generation error: Could not find " +
                            "the randomly assigned LossFilter attribute name.");
            // Helper method to find the strongest type to cast the attribute value to.
            object GetStrongestType(string asString) =>
                Int32.TryParse(asString, out int intValue) ? intValue :
                Double.TryParse(asString, out double dblValue) ? dblValue : (object)asString;
 
            // Get all values in the correct column
            List<string> values = csv.Split('\n').Select(r => r.Split(',')[index.Value])
                // Skip the first value, since it's the header. Then make a distinct list.
                .Skip(1).Distinct().ToList();
            // Get the filter value from an actual row in the column. Get random row value at index
            object value = GetStrongestType(values.ElementAt(_random.Next(values.Count)));
 
            // If this is an AnyOfFilter, pick some random values to create a new list.
            if (IsProperty<AnyOfFilter>(prop, f => f.values))
            {
                List<object> valuesList = values.Where(_ => _random.Next(2) == 0)
                    .Select(GetStrongestType).ToList();
                // Also add the value we picked above (ensures there's at least one item in the list)
                if (!valuesList.Contains(value))
                    valuesList.Add(value);
                return valuesList;
            }
            // Otherwise, the value is just an object we can set directly
            object propertyValue = Convert.ChangeType(value, prop.PropertyType);
            return propertyValue;
        }
 
        private object GenerateParametricLossSetDistributions(PropertyInfo prop, RecursionContext recursionInfo)
        {
            List<Type> allowed = new List<Type>();
            if (IsProperty<ParametricLossSet>(prop, p => p.frequency))
            {
                // Sadly, wonky frequency distributions can lead to really long simulation times,
                // so only try to generate a CustomFrequencyDistribution
                allowed.Add(typeof(IReference<CustomFrequencyDistribution>));
            }
            else
            {
                // Seasonality and severity properties allow for any continuous distribution
                allowed.AddRange(GetAllInstantiableSubtypes(typeof(IReference<IContinuousDistribution>)));
                // But exclude CustomDistribution sub-types that don't correspond with the current property
                allowed.Remove(typeof(Reference<CustomFrequencyDistribution>));
                if (IsProperty<ParametricLossSet>(prop, p => p.seasonality))
                    allowed.Remove(typeof(Reference<CustomSeverityDistribution>));
                else if (IsProperty<ParametricLossSet>(prop, p => p.severity) ||
                    IsProperty<QCLSLossSet>(prop, p => p.distribution))
                    allowed.Remove(typeof(Reference<CustomSeasonalityDistribution>));
            }
            // Generate a random allowed distribution to sub in here.
            Type toGenerate = allowed[_random.Next(allowed.Count)];
            return CreateRandomizedInstance(toGenerate, recursionInfo);
        }
 
        public string GetRandomCurrency()
        {
            if (!Validation_Enabled)
                return Output.RandomString(3, 3, _random);
            HashSet<string> currencies = GetValidCurrenciesForAnalysisProfile(Target_AnalysisProfile);
            return currencies.ElementAt(_random.Next(currencies.Count));
        }
 
        public string PickBackAllocatedLayerSourceId(IReference<ILayerSource> sinkReference)
        {
            ILayerSource sink = Resolve(sinkReference);
            // If the source definition has loss set or layer_view references, use one
            HashSet<string> sourceIds = new HashSet<string>();
            // Take advantage of this recursive test method to collect referenced loss_set and layer_view ids.
            // Note: ValueAllocator 'target' and 'group' properties do not count as "sources"
            //       for back-allocation, so we cannot traverse them to select source ids.
            _ = AnyLayerSourceMatchesCriteria(sink, allocationSourcesOnly: true, test: l =>
                // Gather all nested layer_view ids as potential sources
                l is ILayerView layerViewSource && sourceIds.Add(layerViewSource.id) ||
                // Gather all nested loss set ids as potential sources
                l is ILayer_WithLossSets withLossSets && !withLossSets.loss_sets.All(ls => sourceIds.Add(ls.ref_id)));
 
            // If the sink was a layer_view reference, its id can also be used as a possible source_id
            if (sink is ILayerView sinkAsLayerView)
                sourceIds.Add(sinkAsLayerView.id ?? CacheResource(sinkAsLayerView.Post()).ref_id);
            // Otherwise, if we haven't found any valid sources ids, raise an error.
            // Note: We have no way to know what the parent layer_view (and therefore its
            //   target_currency) is or will be, so we cannot simply post the sink layer as a
            //   layer_view to generate a source_id - it might not match the internally generated id.
            if (!sourceIds.Any())
                throw new PropertyGenerationException("Cannot generate a valid BackAllocatedLayer." +
                    "source_id because the sink contains no layer_view or loss set ids to reference:\n" +
                    sink.Serialize());
            return sourceIds.Skip(_random.Next(sourceIds.Count)).First();
        }
        #endregion Specific Property Generation Helper Routines
        #endregion Type Specific Random Generation Helpers
 
        #region Validation Helper Methods
        public T TryGenerate<T>(Func<T> generator, Func<T, bool> validation_test,
            Func<string> get_error, PropertyInfo property, bool exception_on_failure = true,
            RecursionContext recursionInfo = null)
        {
            return LimitAttempts(generator,
                Validation_Enabled ? validation_test : (arg => true), get_error,
                property, 1, exception_on_failure, recursionInfo);
        }
 
        public static T LimitAttempts<T>(Func<T> generator, Func<T, bool> validation_test,
            Func<string> get_error, PropertyInfo property = null,
            int max_attempts = Max_ReRandomize_Attempts, bool exception_on_failure = true,
            RecursionContext recursionInfo = null)
        {
            string msg = " to generate an acceptable " + (property == null ? "object" :
                    $"value for the {property.ReflectedType.NiceTypeName()} property " +
                    $"{property.DeclaringType.NiceTypeName()}.{property.Name}") +
                $" (type {(property?.PropertyType ?? typeof(T)).NiceTypeName()}) failed: ";
            T tentative = default(T);
            int attempts = 0;
            bool valid = false;
            string error = msg;
            recursionInfo = recursionInfo ?? new RecursionContext(typeof(T));
            while (attempts++ < max_attempts && !valid)
            {
                tentative = generator();
                valid = validation_test(tentative);
                if (!valid)
                {
                    error = msg + (get_error?.Invoke() ?? "(no reason given)");
                    if (attempts < max_attempts)
                        recursionInfo.LogIndented($"Attempt {attempts}/{max_attempts} {error}");
                }
            }
            if (valid)
                return tentative;
            error = (max_attempts > 1 ? $"Final attempt ({max_attempts})" : "Attempt") + error;
            if (exception_on_failure)
                throw new PropertyGenerationException(error);
            recursionInfo.LogIndented($"{error} Returning default(T).");
            return default(T);
        }
 
        public static bool IsProperty<TPropertyOwner>(PropertyInfo property,
            Expression<Func<TPropertyOwner, object>> propertyExpression) =>
            // The property expression must resolve to some property info
            ReflectionUtilities.GetMemberInfo(propertyExpression) is PropertyInfo pi &&
            // Either the runtime PropertyInfo is the same property that the expression indicates,
            // or the object that was used to obtain this property derives from TPropertyOwner
            // and the current property name matches the name of the desired property
            // (presumably because the object inherits, overrides, or hides the base property)
            (pi == property || pi.Name == property.Name &&
                typeof(TPropertyOwner).IsAssignableFrom(property.ReflectedType));
 
        #region Validation Against Analysis Profile
        private readonly ConcurrentDictionary<string, HashSet<string>> _cachedValidCurrenciesByAnalysisProfile =
            new ConcurrentDictionary<string, HashSet<string>>();
 
        public HashSet<string> GetValidCurrenciesForAnalysisProfile(AnalysisProfile analysis_profile) =>
            analysis_profile?.exchange_rate_profile?.ref_id == null ?
                throw new ArgumentException("This analysis profile to has no exchange rate profile!") :
                _cachedValidCurrenciesByAnalysisProfile.GetOrAdd(analysis_profile.exchange_rate_profile.ref_id, _ =>
                {
                    ExchangeRateTable fxTable = analysis_profile.exchange_rate_profile.GetValue()
                        .exchange_rate_table.GetValue();
                    string[] rows = fxTable.data.Get().Split('\n');
                    int ccyCol = rows[0].Split(',').Where((col, index) => col.ToLower().Contains("currency"))
                        .Select((col, index) => index).First();
                    return new HashSet<string>(rows.Skip(1).Select(r => r.Split(',')[ccyCol]),
                        StringComparer.InvariantCultureIgnoreCase) { fxTable.base_currency };
                });
 
        public bool ResourceIsValidForAnalysisProfile(IAPIResource to_validate, AnalysisProfile rootAp)
        {
            if (to_validate == null) return true;
            if (to_validate is IAPIAnalysis apiAnalysis)
            {
                // If the root-level resource has been posted and the analysis profile matches, we can
                // rest assured that the server has done all analysis_profile-related validation.
                // Therefore, any posted resource (i.e. with an id) requires no further validation.
                if (apiAnalysis is IAPIResource asResource && asResource.id != null &&
                    apiAnalysis.analysis_profile.ref_id == rootAp.id)
                    return true;
 
                // Otherwise, check for conditions that would make this IAPIAnalysis invalid:
                // 1. Check that the target currency is valid for the current analysis profile
                if (!GetValidCurrenciesForAnalysisProfile(rootAp).Contains(apiAnalysis.target_currency))
                    return false;
                // 2. Ensure all nested analysis objects' analysis profiles match
                if (AnyAnalysisMatchesCriteria(apiAnalysis, a => rootAp.id != a.analysis_profile.ref_id))
                    return false;
            }
            // Posted resource with a status must have a success status to be used in any context.
            if (to_validate is IStoredAPIResource_WithStatus asWithStatus &&
                asWithStatus.id != null && asWithStatus.status != TaskStatus.Success)
                return false;
 
            // Other resources must be checked in depth to see if they *would* pass server validation.
            if (to_validate is LossSet lossSet)
                return LossSetIsValidForAnalysisProfile(lossSet, rootAp);
            if (to_validate is ILayerSource layerOrLayerView)
                return LayerSourceIsValidForAnalysisProfile(layerOrLayerView, rootAp);
 
            if (to_validate is Portfolio portfolio)
                return portfolio.layers.All(lyr =>
                    ResourceIsValidForAnalysisProfile(Resolve(lyr), rootAp));
            if (to_validate is PortfolioView portfolioView)
                return portfolioView.layer_views?.All(lv =>
                        ResourceIsValidForAnalysisProfile(Resolve(lv), rootAp)) ??
                    ResourceIsValidForAnalysisProfile(Resolve(portfolioView.portfolio), rootAp);
            if (to_validate is OptimizationView optimizationView)
                return optimizationView.domains.All(d =>
                    ResourceIsValidForAnalysisProfile(Resolve(d.layer), rootAp));
            // Any other resources types probably have no validation rules.
            return true;
        }
 
        public bool LayerSourceIsValidForAnalysisProfile(ILayerSource to_validate, AnalysisProfile analysis_profile)
        {
            if (to_validate == null) return true;
            // Collect some information used to test all layer definitions
            HashSet<string> validCurrencies = GetValidCurrenciesForAnalysisProfile(analysis_profile);
            // Build a test function for a single layerSource (layer or layer_view)
            // TODO: Double negatives are confusing (returns true when invalid) - try to flip this around
            bool IsCurrentLayerInvalid(ILayerSource layerSource)
            {
                // Ensure no referenced layer_views have a conflicting analysis profile
                if (layerSource is ILayerView layerView &&
                    layerView.analysis_profile.ref_id != analysis_profile.id)
                    return true;
                // Test that any monetary units are valid for the analysis profile
                // A monetary unit (and thus, this layer) is invalid to use if:
                // 1. It references a currency not in the exchange rate table of the analysis profile
                // 2. It references a specific "value_date" (difficult to verify - assume not valid)
                foreach (PropertyInfo prop in layerSource.GetType().GetUserFacingProperties(true, true, true)
                    .Where(p => typeof(MonetaryUnit).IsAssignableFrom(p.PropertyType)))
                {
                    if (prop.GetValue(layerSource) is MonetaryUnit mu &&
                        (!validCurrencies.Contains(mu.currency) || mu.value_date != null))
                        return true;
                }
                // Ensure all referenced loss sets are compatible with this profile
                if (layerSource is ILayer_WithLossSets layerWithLossSets &&
                    layerWithLossSets.loss_sets.Any(ls =>
                        !ResourceIsValidForAnalysisProfile(Resolve(ls), analysis_profile)))
                    return true;
 
                // If none of the above checks detected any issues, assume the layer is valid.
                return false;
            }
            // Use a helper to recursively test this and any inlined sources
            return !AnyLayerMatchesCriteria(to_validate, IsCurrentLayerInvalid);
        }
 
        public bool LossSetIsValidForAnalysisProfile(LossSet to_validate, AnalysisProfile analysis_profile)
        {
            if (to_validate == null) return true;
            // Collect some information used to test all layer definitions
            HashSet<string> validCurrencies = GetValidCurrenciesForAnalysisProfile(analysis_profile);
            HashSet<string> validCatalogIds = new HashSet<string>(
                analysis_profile.event_catalogs.Select(e => e.ref_id));
            // Build a test function for a single loss set
            // TODO: Double negatives are confusing (returns true when invalid) - try to flip this around
            bool IsCurrentLossSetInvalid(LossSet lossSet)
            {
                // If this loss set has associated data, ensure it has completed processing
                if (lossSet is LossSet_WithData lossSetWithData &&
                    lossSetWithData.status != TaskStatus.Success)
                    return true;
                // If this loss set has a currency, ensure it is valid for this analysis profile
                if (lossSet is LossSet_WithCurrency asWithCurrency &&
                    !validCurrencies.Contains(asWithCurrency.currency))
                    return true;
                // If this loss set has event catalogs, and any aren't valid, loss set is invalid
                if (lossSet is ILossSet_WithEventCatalog withEventCatalog &&
                    withEventCatalog.event_catalogs.Any(e => !validCatalogIds.Contains(e.ref_id)))
                    return true;
                // If this loss set has a simulation (QCLS), and any of the simulation's catalogs
                // aren't valid, then this loss set is invalid
                if (lossSet is QCLSLossSet asQCLSLossSet && Resolve(asQCLSLossSet.simulation)
                    .event_catalogs.Any(e => !validCatalogIds.Contains(e.ref_id)))
                    return true;
                // If this is a parametric loss set, ensure its distributions are valid
                if (lossSet is ParametricLossSet parametric &&
                    Resolve(parametric.frequency) is IDiscreteDistribution distribution &&
                    !TestSuite_Distribution_Base.IsFrequencyDistributionSafeToSimulate(distribution))
                    return true;
#pragma warning disable 618
                // If this is a NestedLayerLossSet, ensure that its associated loss source
                // is valid for the current analysis profile.
                if (lossSet is NestedLayerLossSet asNestedLayerLossSet &&
                    !ResourceIsValidForAnalysisProfile(Resolve(asNestedLayerLossSet.layer), analysis_profile))
                    return true;
#pragma warning restore 618
                // Otherwise, this loss set appears to be valid.
                return false;
            }
 
            // Use a helper to recursively test this and any inlined loss sets
            return !AnyLossSetMatchesCriteria(to_validate, IsCurrentLossSetInvalid);
        }
        #endregion Validation Against Analysis Profile
        #endregion Validation Helper Methods
 
        #region Request Logging
        private int _nestedBrCalls = 0;
 
        public class TimedRequest : Tuple<DateTime, string, RecursionContext, int, int>
        {
            public DateTime Start => Item1;
            public string Description => Item2;
            public int ThreadId => Item4;
 
            public RecursionContext RecursionInfo => Item3;
 
            public int NestingLevel => Item5;
 
            public TimedRequest(DateTime start, string description,
                RecursionContext recursionLevel, int threadId, int nestingLevel)
                : base(start, description, recursionLevel, threadId, nestingLevel) { }
        }
        private readonly ConcurrentDictionary<string, TimedRequest> _requestInfo =
            new ConcurrentDictionary<string, TimedRequest>();
        private readonly object _requestTrackingLock = new object();
 
        [Conditional("DEBUG")]
        private void BeginRequest(RecursionContext recursionInfo, string uniqueKey)
        {
            TimedRequest reqInfo;
            lock (_requestTrackingLock)
            {
                reqInfo = _requestInfo[uniqueKey] = new TimedRequest(
                    DateTime.UtcNow, uniqueKey, recursionInfo, Thread.CurrentThread.ManagedThreadId, _nestedBrCalls);
                _nestedBrCalls++;
            }
            recursionInfo.LogIndented($"N:{reqInfo.NestingLevel} " +
                $"Thread {reqInfo.ThreadId} Started Request: {uniqueKey}");
        }
 
        [Conditional("DEBUG")]
        private void EndRequest(string uniqueKey, string message = "")
        {
            TimedRequest reqInfo;
            string log;
            lock (_requestTrackingLock)
            {
                _nestedBrCalls--;
                if (_nestedBrCalls < 0)
                {
                    Debug.WriteLine("EndRequest called more than BeginRequest. Timings may be off.");
                    _nestedBrCalls = 0;
                }
 
                reqInfo = _requestInfo[uniqueKey];
                log = $"N:{_nestedBrCalls} Thread {reqInfo.ThreadId} " +
                    $"Finished in {(DateTime.UtcNow - reqInfo.Start).TotalMilliseconds}ms: " +
                    reqInfo.Description + (message == null ? "" : $" - {message}");
            }
            reqInfo.RecursionInfo.LogIndented(log);
        }
        #endregion Request Logging
 
        #region General Helper Methods
        // A cache of the list of unsupported types.
        private static readonly HashSet<Type> CachedUnsupportedTypes = new HashSet<Type>();
        // Used to determine if the cache is populated without locking
        private static volatile bool _isCachedAPIResourceCollectionsPopulated = false;
 
        private static HashSet<Type> GetUnsupportedTypes()
        {
            if (_isCachedAPIResourceCollectionsPopulated)
                return CachedUnsupportedTypes;
            // Ensure more than one thread doesn't try to populate the list.
            lock (CachedUnsupportedTypes)
            {
                // If another thread populated it since taking the lock, return
                if (_isCachedAPIResourceCollectionsPopulated)
                    return CachedUnsupportedTypes;
 
                // Certain types can appear as inlined objects but should not be considered an
                // instantiable type, since they cannot be posted to their collection on their own.
                // (e.g.FilterLayer, FixedRateCurrencyConverter)
                foreach (Type unusable in TypeResolver.GetAllInstantiableSubtypes(typeof(IAPIResource))
                    .Where(t => t.IsAttributeDefinedFast<ObsoleteAttribute>() ||
                        t.IsAttributeDefinedFast<NotSaveableAttribute>()))
                    CachedUnsupportedTypes.Add(unusable);
                // Add to this list references to any of the above objects
                foreach (Type t in CachedUnsupportedTypes.ToList())
                    CachedUnsupportedTypes.Add(typeof(IReference<>).MakeGenericTypeFast(t));
 
                _isCachedAPIResourceCollectionsPopulated = true;
                return CachedUnsupportedTypes;
            }
        }
 
        private static readonly ConcurrentDictionary<Type, HashSet<Type>> CachedInstantiableSubtypes =
            new ConcurrentDictionary<Type, HashSet<Type>>();
 
        public static IEnumerable<Type> GetAllInstantiableSubtypes(Type type)
        {
            HashSet<Type> instantiableSubtypes = CachedInstantiableSubtypes.GetOrAdd(type, T =>
            {
                HashSet<Type> subTypes = new HashSet<Type>(TypeResolver.GetAllInstantiableSubtypes(T));
                // If the requested type itself is not marked as obsolete or otherwise unsupported,
                // Remove any instantiable subtypes that derive from unsupported or disabled types.
                HashSet<Type> unsupported = GetUnsupportedTypes();
                if (!unsupported.Contains(T) && !T.IsAttributeDefinedFast<ObsoleteAttribute>())
                    subTypes.RemoveWhere(subtype => unsupported.Contains(subtype) ||
                        unsupported.Any(t_unsupported => t_unsupported.IsAssignableFrom(subtype)));
                return subTypes;
            });
            Assert.AreNotEqual(0, instantiableSubtypes.Count,
                $"Could not find any instantiable any objects of type {type.NiceTypeName()}");
            return instantiableSubtypes;
        }
 
        #region Recursive Tests
        public bool AnyAnalysisMatchesCriteria(IAPIAnalysis analysis, Func<IAPIAnalysis, bool> test)
        {
            // Run the test for the current analysis object.
            if (test(analysis)) return true;
            // Recurse on PortfolioView layer_views.
            if (analysis is PortfolioView pv &&
                (pv.layer_views?.Any(lv => AnyAnalysisMatchesCriteria(Resolve(lv), test)) ?? false))
                return true;
            if (analysis is ILayerView analysisAsLayerView)
            {
                // Recurse on Nested layer_view references.
                bool TestLayerSource(IReference<ILayerSource> sourceReference) =>
                    sourceReference is IReference<ILayerView> layerViewReference &&
                    AnyAnalysisMatchesCriteria(Resolve(layerViewReference), test);
 
                if (analysisAsLayerView.layer is Nested asNested)
                {
                    if (TestLayerSource(asNested.sink)) return true;
                    if (asNested.sources.Any(TestLayerSource)) return true;
                }
                else if (analysisAsLayerView.layer is ValueAllocator asValueAllocator)
                {
                    if (TestLayerSource(asValueAllocator.source)) return true;
                    if (TestLayerSource(asValueAllocator.target)) return true;
                    if (TestLayerSource(asValueAllocator.group)) return true;
                }
            }
 
            return false;
        }
 
        public static ILayer GetLayerDefinition(ILayerSource layerSource) =>
            layerSource == null ? throw new ArgumentNullException(nameof(layerSource)) :
            layerSource is ILayer asLayer ? asLayer :
            layerSource is ILayerView asLayerView ? asLayerView.layer :
            throw new ArgumentException($"Unrecognized {nameof(layerSource)} type: {layerSource.GetType()}");
 
        public bool AnyLayerMatchesCriteria(ILayerSource rootlayerSource, Func<ILayer, bool> test,
            bool allocationSourcesOnly = false) =>
            AnyLayerSourceMatchesCriteria(rootlayerSource, ls => test(GetLayerDefinition(ls)),
                allocationSourcesOnly);
 
        public bool AnyLayerSourceMatchesCriteria(ILayerSource rootLayerSource,
            Func<ILayerSource, bool> test, bool allocationSourcesOnly = false)
        {
            // Run the test for the current layerSource.
            if (test(rootLayerSource)) return true;
            // Run the test on any nested layers sets in this structure.
 
            // If this source contains a layer definition with nested references, test them recursively
            ILayer rootDefinition = GetLayerDefinition(rootLayerSource);
            bool TestLayerSource(IReference<ILayerSource> sourceReference) =>
                sourceReference != null &&
                AnyLayerMatchesCriteria(Resolve(sourceReference), test, allocationSourcesOnly);
 
            if (rootDefinition is Nested asNested)
            {
                if (TestLayerSource(asNested.sink)) return true;
                if (asNested.sources.Any(TestLayerSource)) return true;
            }
            else if (rootDefinition is ValueAllocator asValueAllocator)
            {
                if (TestLayerSource(asValueAllocator.source)) return true;
                if (!allocationSourcesOnly)
                {
                    if (TestLayerSource(asValueAllocator.target)) return true;
                    if (TestLayerSource(asValueAllocator.group)) return true;
                }
            }
            else if (rootDefinition is BackAllocatedLayer asBackAllocatedLayer)
            {
                if (TestLayerSource(asBackAllocatedLayer.sink)) return true;
            }
#pragma warning disable 618
            // If this layer has loss sets, one or more of them may contain a nested layer.
            else if (rootDefinition is ILayer_WithLossSets asWithLossSets)
            {
                // Return true if any nested loss set contains a layer that returns true for 'test'
                // Currently, this is only possible for the NestedLayerLossSet
                return asWithLossSets.loss_sets.Any(ls => AnyLossSetMatchesCriteria(Resolve(ls),
                    lossSet => lossSet is NestedLayerLossSet nlls &&
                        AnyLayerMatchesCriteria(Resolve(nlls.layer), test, allocationSourcesOnly)));
            }
#pragma warning restore 618
            return false;
        }
 
        public bool AnyLossSetMatchesCriteria(LossSet root, Func<LossSet, bool> test)
        {
            // Run the test for the current loss set
            if (test(root)) return true;
            // Run the test on any nested loss sets in this structure.
            // If this is a loaded loss set, it has a nested loss set "source"
            if (root is LoadedLossSet asLoaded)
            {
                if (AnyLossSetMatchesCriteria(Resolve(asLoaded.source), test))
                    return true;
            }
#pragma warning disable 618
            // If this is a NestedLayerLossSet, it's layer structure may have one or more loss sets.
            else if (root is NestedLayerLossSet asNestedLayerLossSet)
            {
                // Recursively check the loss sets of this layer and any layers it may contain
                // Return true IFF this layer has loss sets and any of them return true for 'test'
                if (AnyLayerMatchesCriteria(Resolve(asNestedLayerLossSet.layer),
                    layer => layer is ILayer_WithLossSets asWithLossSets && asWithLossSets
                        .loss_sets.Any(ls => AnyLossSetMatchesCriteria(Resolve(ls), test))))
                    return true;
            }
#pragma warning restore 618
            return false;
        }
        #endregion Recursive Tests
        #endregion General Helper Methods
    }
 
    [Serializable]
    public class PropertyGenerationException : Exception
    {
        public PropertyGenerationException(string message) : base(message) { }
 
        public PropertyGenerationException(string message, Exception inner_exception)
            : base(message, inner_exception) { }
    }
}