mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
336 lines
13 KiB
C#
336 lines
13 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
using System;
|
|
using System.Linq;
|
|
using System.UnitTesting;
|
|
using System.Collections.Generic;
|
|
using Microsoft.Internal.Collections;
|
|
using System.Reflection;
|
|
using System.Globalization;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections;
|
|
using System.ComponentModel.Composition.Factories;
|
|
using System.ComponentModel.Composition.Hosting;
|
|
using System.ComponentModel.Composition.Primitives;
|
|
using System.ComponentModel.Composition.AttributedModel;
|
|
using System.ComponentModel.Composition.ReflectionModel;
|
|
using System.Reflection.Emit;
|
|
|
|
namespace System.ComponentModel.Composition
|
|
{
|
|
internal static class Expectations
|
|
{
|
|
public static IEnumerable<CultureInfo> GetCulturesForFormatting()
|
|
{
|
|
yield return new CultureInfo("en-US"); // English (US)
|
|
yield return new CultureInfo("en-AU"); // English (Australian)
|
|
yield return new CultureInfo("en-CA"); // English (Canada)
|
|
yield return new CultureInfo("en-NZ"); // English (Great Britain)
|
|
yield return new CultureInfo("en-JM"); // English (Jamaica)
|
|
yield return new CultureInfo("pt-BR"); // Portuguese (Brazil)
|
|
yield return new CultureInfo("es-AR"); // Spanish (Argentina)
|
|
yield return new CultureInfo("ja-JP"); // Japanese (Japan)
|
|
yield return new CultureInfo("fr-FR"); // French (France)
|
|
yield return new CultureInfo("it-IT"); // Italian (Italy)
|
|
yield return new CultureInfo("de-DE"); // German (Germany)
|
|
yield return new CultureInfo("es-ES"); // Spanish (Spain)
|
|
yield return new CultureInfo("ko-KR"); // Korean (Korea)
|
|
yield return new CultureInfo("zh-TW"); // Chinese (Taiwan)
|
|
yield return new CultureInfo("zh-CN"); // Chinese (People's Republic of China)
|
|
}
|
|
|
|
public static IEnumerable<Assembly> GetAssemblies()
|
|
{
|
|
yield return Assembly.GetExecutingAssembly();
|
|
yield return Assembly.Load("mscorlib");
|
|
}
|
|
|
|
public static IEnumerable<string> GetDisplayNames()
|
|
{
|
|
yield return "";
|
|
yield return " ";
|
|
yield return " ";
|
|
yield return "DisplayName";
|
|
yield return "displayname";
|
|
yield return "This is the display name.";
|
|
}
|
|
|
|
public static IEnumerable<ICompositionElement> GetCompositionElements()
|
|
{
|
|
yield return ElementFactory.CreateChain(1);
|
|
yield return ElementFactory.CreateChain(2);
|
|
yield return ElementFactory.CreateChain(3);
|
|
yield return ElementFactory.CreateChain(5);
|
|
yield return ElementFactory.CreateChain(10);
|
|
}
|
|
|
|
public static IEnumerable<ICompositionElement> GetCompositionElementsWithNull()
|
|
{
|
|
foreach (var element in GetCompositionElements())
|
|
{
|
|
yield return element;
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
public static IEnumerable<ComposablePartCatalog> GetCatalogs()
|
|
{
|
|
yield return CatalogFactory.Create();
|
|
yield return CatalogFactory.CreateDefaultAttributed();
|
|
}
|
|
|
|
public static IEnumerable<IEnumerable<CompositionError>> GetCompositionErrors()
|
|
{
|
|
foreach (var value in GetEmptyCollections<CompositionError>())
|
|
{
|
|
yield return value;
|
|
}
|
|
|
|
yield return new CompositionError[] { new CompositionError("") };
|
|
yield return new CompositionError[] { new CompositionError(""), new CompositionError("Description") };
|
|
yield return new CompositionError[] { new CompositionError(""), new CompositionError("Description"), ErrorFactory.Create(CompositionErrorId.InvalidExportMetadata, "Description", (Exception)null), ErrorFactory.Create(CompositionErrorId.Unknown, "Description", new Exception()) };
|
|
}
|
|
|
|
public static IEnumerable<string> GetContractNames()
|
|
{
|
|
yield return " ";
|
|
yield return " ";
|
|
yield return "ContractName";
|
|
yield return "contractName";
|
|
yield return "{ContractName}";
|
|
yield return "{ContractName}Name";
|
|
yield return "System.Windows.Forms.Control";
|
|
yield return "{System.Windows.Forms}Control";
|
|
yield return "{9}Control";
|
|
}
|
|
|
|
public static IEnumerable<string> GetContractNamesWithEmpty()
|
|
{
|
|
foreach (string contractName in GetContractNames())
|
|
{
|
|
yield return contractName;
|
|
}
|
|
|
|
yield return string.Empty;
|
|
}
|
|
|
|
public static IEnumerable<object> GetObjectsReferenceTypes()
|
|
{
|
|
yield return "Value";
|
|
yield return new Collection<string>();
|
|
yield return new IEnumerable[0];
|
|
}
|
|
|
|
public static IEnumerable<ValueType> GetObjectsValueTypes()
|
|
{
|
|
yield return 10;
|
|
yield return 10.0;
|
|
yield return DayOfWeek.Wednesday;
|
|
}
|
|
|
|
public static IEnumerable<string> GetMetadataNames()
|
|
{
|
|
return GetContractNamesWithEmpty();
|
|
}
|
|
|
|
public static IEnumerable<object> GetMetadataValues()
|
|
{
|
|
yield return null;
|
|
yield return string.Empty;
|
|
yield return "";
|
|
yield return " ";
|
|
yield return " ";
|
|
yield return (Int32)1;
|
|
yield return (Byte)1;
|
|
yield return (Single)1.1;
|
|
yield return (Double)1.1;
|
|
yield return DayOfWeek.Wednesday;
|
|
}
|
|
|
|
public static IEnumerable<Dictionary<string, Type>> GetRequiredMetadata()
|
|
{
|
|
yield return new Dictionary<string, Type> { { "", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { " ", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { " ", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { " ", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "A", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "A", typeof(object) }, { "B", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "A", typeof(object) }, { "B", typeof(object) }, { "C", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "a", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "a", typeof(object) }, { "b", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "a", typeof(object) }, { "b", typeof(object) }, { "c", typeof(object) } };
|
|
yield return new Dictionary<string, Type> { { "Metadata1", typeof(object) }, { "Metadata2", typeof(object) }, { "Metadata3", typeof(object) } };
|
|
}
|
|
|
|
public static IEnumerable<Dictionary<string, Type>> GetRequiredMetadataWithEmpty()
|
|
{
|
|
foreach (var requiredMetadata in GetRequiredMetadata())
|
|
{
|
|
yield return requiredMetadata;
|
|
}
|
|
|
|
yield return new Dictionary<string, Type>();
|
|
}
|
|
|
|
public static IEnumerable<IDictionary<string, object>> GetMetadata()
|
|
{
|
|
yield return new ReadOnlyDictionary<string, object>(null);
|
|
yield return new Dictionary<string, object>();
|
|
|
|
#if !SILVERLIGHT
|
|
|
|
yield return new SortedDictionary<string, object>();
|
|
yield return new SortedList<string, object>();
|
|
|
|
#endif
|
|
var metadata = new Dictionary<string, object>();
|
|
metadata.Add("One", "Value");
|
|
metadata.Add("Two", true);
|
|
metadata.Add("Three", 10);
|
|
metadata.Add("Four", 1.0);
|
|
metadata.Add("Five", null);
|
|
|
|
yield return metadata;
|
|
}
|
|
|
|
public static IEnumerable<string> GetExceptionMessages()
|
|
{
|
|
yield return "";
|
|
yield return " ";
|
|
yield return " ";
|
|
yield return "message";
|
|
yield return "This is an error message.";
|
|
yield return "Line One." + Environment.NewLine + "Line Two.";
|
|
}
|
|
|
|
public static IEnumerable<Exception> GetInnerExceptions()
|
|
{
|
|
yield return new Exception();
|
|
yield return new ArgumentException();
|
|
yield return new SystemException();
|
|
#if CLR40
|
|
yield return new CompositionException();
|
|
yield return new ImportCardinalityMismatchException();
|
|
#endif
|
|
}
|
|
|
|
public static IEnumerable<Exception> GetInnerExceptionsWithNull()
|
|
{
|
|
foreach (var exception in GetInnerExceptions())
|
|
{
|
|
yield return exception;
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
public static IEnumerable<bool> GetBooleans()
|
|
{
|
|
yield return false;
|
|
yield return true;
|
|
yield return false;
|
|
yield return true;
|
|
}
|
|
|
|
public static IEnumerable<ReflectionComposablePartDefinition> GetAttributedDefinitions()
|
|
{
|
|
foreach (var type in GetAttributedTypes())
|
|
{
|
|
yield return PartDefinitionFactory.CreateAttributed(type);
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<Type> GetTypes()
|
|
{
|
|
yield return typeof(void);
|
|
yield return typeof(Type);
|
|
yield return typeof(double);
|
|
yield return typeof(string);
|
|
yield return typeof(int);
|
|
yield return typeof(CompositionServices);
|
|
yield return typeof(ICompositionService);
|
|
}
|
|
|
|
public static IEnumerable<Type> GetAttributedTypes()
|
|
{
|
|
foreach (Type type in typeof(Expectations).Assembly.GetTypes())
|
|
{
|
|
var definition = AttributedModelDiscovery.CreatePartDefinitionIfDiscoverable(type, (ICompositionElement)null);
|
|
if (definition != null)
|
|
{
|
|
yield return type;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<MemberInfo> GetMembers()
|
|
{
|
|
yield return typeof(String).GetSingleMember("Length");
|
|
yield return typeof(Int32).GetSingleMember("MaxValue");
|
|
}
|
|
|
|
public static IEnumerable<TEnum> GetEnumValues<TEnum>() where TEnum : struct
|
|
{
|
|
var values = TestServices.GetEnumValues<TEnum>();
|
|
|
|
foreach (TEnum value in values)
|
|
{
|
|
yield return value;
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<TEnum> GetInvalidEnumValues<TEnum>() where TEnum : struct
|
|
{
|
|
var bounds = GetEnumBounds<TEnum>();
|
|
|
|
yield return AddEnum(bounds.Item1, -3);
|
|
yield return AddEnum(bounds.Item1, -2);
|
|
yield return AddEnum(bounds.Item1, -1);
|
|
yield return AddEnum(bounds.Item2, 1);
|
|
yield return AddEnum(bounds.Item2, 2);
|
|
yield return AddEnum(bounds.Item2, 3);
|
|
yield return (TEnum)(object)(int.MinValue + 1);
|
|
yield return (TEnum)(object)int.MinValue;
|
|
yield return (TEnum)(object)int.MaxValue;
|
|
yield return (TEnum)(object)(int.MaxValue - 1);
|
|
}
|
|
|
|
public static IEnumerable<object[]> GetObjectArraysWithNull()
|
|
{
|
|
yield return null;
|
|
yield return new object[0];
|
|
yield return new object[] { null };
|
|
yield return new string[] { null };
|
|
yield return new object[] { 1, "2", 3.0 };
|
|
yield return new string[] { "1" };
|
|
yield return new string[] { "1", "2" };
|
|
yield return new string[] { "1", "2", "3" };
|
|
}
|
|
|
|
private static TEnum AddEnum<TEnum>(TEnum left, int right) where TEnum : struct
|
|
{
|
|
int intRight = (int)(object)left;
|
|
|
|
return (TEnum)(object)(intRight + right);
|
|
}
|
|
|
|
private static Tuple<TEnum, TEnum> GetEnumBounds<TEnum>() where TEnum : struct
|
|
{
|
|
var values = TestServices.GetEnumValues<TEnum>();
|
|
|
|
return new Tuple<TEnum, TEnum>(values.First(), values.Last());
|
|
}
|
|
|
|
private static IEnumerable<IEnumerable<T>> GetEmptyCollections<T>()
|
|
{
|
|
yield return new T[0];
|
|
yield return Enumerable.Empty<T>();
|
|
yield return new List<T>();
|
|
yield return new Collection<T>();
|
|
yield return new Dictionary<T, object>().Keys;
|
|
}
|
|
}
|
|
} |