public void TestOptionSearchDuplicateParameters(Parameters parameter, DuplicateTypes inputType)
        {
            var optionSearchHandler = new OptionSearchManager();
            var response            = optionSearchHandler.OptionSearch <OptionSearchAliasResponse>(DuplicateOptionData[parameter](inputType), System.Net.Http.HttpMethod.Post);

            PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
        }
        private static TypeMap AddTypeMap(Type type)
        {
            lock (SyncRoot) {
                var typeName = type.Name.ToLower();

                // Skip dynamic/runtime classes
                if (typeName.Contains(">"))
                {
                    return(null);
                }

                if (Types.ContainsKey(typeName))
                {
                    var existing = Types[typeName];
                    DuplicateTypes.Add(type);
                    DuplicateTypes.Add(existing.Type);
                }
                else
                {
                    var map = new TypeMap(type);

                    Types.Add(typeName, map);

                    //foreach (var name in type.GetTypeNames()) {
                    //    Types.Add(name.ToLower(), map);
                    //}
                }

                return(Types[typeName]);
            }
        }
        public void TestOriginalSearchDuplicateParameters(Parameters parameter, DuplicateTypes inputType, ConditionTypes conditionTypes)
        {
            var handler  = new OriginalSearchManager(conditionTypes == ConditionTypes.Dialog ? ConditionEndpoint : null);
            var response = handler.OriginalSearch <object>(DuplicateOriginalSearchData[parameter](inputType, conditionTypes), System.Net.Http.HttpMethod.Get);

            PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
        }
        public static void Initialize(params Assembly[] assemblies)
        {
            try {
                lock (SyncRoot) {
                    if (IsInitialized)
                    {
                        throw new Exception("Reflection cache is already initialized.");
                    }

                    IsInitialized = true;

                    foreach (var assembly in assemblies)
                    {
                        foreach (var type in assembly.DefinedTypes)
                        {
                            AddTypeMap(type);
                        }

                        if (DuplicateTypes.Any())
                        {
                            //throw new Exception("Duplicate types found: " + string.Join(" ", duplicates.Select(each => each.FullName + Environment.NewLine)));
                        }
                    }

                    MapDerivedTypes();
                    MapExtensionMethods(assemblies);
                }
            }
            catch (ReflectionTypeLoadException ex) {
                var exceptions = ex.LoaderExceptions;
                throw ex;
            }
        }