mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-27 00:07:58 +01:00
43b889d1b1
* Remove the old short two digits year and done some cleanup. * Fixes #3160. TextField doesn't update correctly the CursorPosition on Paste. * Using TextChanging instead of TextChanged event. * Removes old IsShortFormat. * Removing unnecessary private fields and done code cleanup. * Removes unnecessary GetShortDatePattern method, * Fix AdjCursorPosition method. * Create TestDateAttribute. * Reduces indentation and removes unused using. * Remove location from constructors parameters.
581 lines
19 KiB
C#
581 lines
19 KiB
C#
using CsvHelper.Configuration.Attributes;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using Xunit;
|
|
using Xunit.Abstractions;
|
|
using Xunit.Sdk;
|
|
|
|
namespace Terminal.Gui;
|
|
|
|
// This class enables test functions annotated with the [AutoInitShutdown] attribute to
|
|
// automatically call Application.Init at start of the test and Application.Shutdown after the
|
|
// test exits.
|
|
//
|
|
// This is necessary because a) Application is a singleton and Init/Shutdown must be called
|
|
// as a pair, and b) all unit test functions should be atomic..
|
|
[AttributeUsage (AttributeTargets.Class | AttributeTargets.Method)]
|
|
public class AutoInitShutdownAttribute : BeforeAfterTestAttribute {
|
|
readonly Type _driverType;
|
|
|
|
/// <summary>
|
|
/// Initializes a [AutoInitShutdown] attribute, which determines if/how Application.Init and
|
|
/// Application.Shutdown are automatically called Before/After a test runs.
|
|
/// </summary>
|
|
/// <param name="autoInit">If true, Application.Init will be called Before the test runs.</param>
|
|
/// <param name="autoShutdown">If true, Application.Shutdown will be called After the test runs.</param>
|
|
/// <param name="consoleDriverType">
|
|
/// Determines which ConsoleDriver (FakeDriver, WindowsDriver,
|
|
/// CursesDriver, NetDriver) will be used when Application.Init is called. If null FakeDriver will be used.
|
|
/// Only valid if <paramref name="autoInit"/> is true.
|
|
/// </param>
|
|
/// <param name="useFakeClipboard">
|
|
/// If true, will force the use of <see cref="FakeDriver.FakeClipboard"/>.
|
|
/// Only valid if <see cref="ConsoleDriver"/> == <see cref="FakeDriver"/> and <paramref name="autoInit"/> is true.
|
|
/// </param>
|
|
/// <param name="fakeClipboardAlwaysThrowsNotSupportedException">
|
|
/// Only valid if <paramref name="autoInit"/> is true.
|
|
/// Only valid if <see cref="ConsoleDriver"/> == <see cref="FakeDriver"/> and <paramref name="autoInit"/> is true.
|
|
/// </param>
|
|
/// <param name="fakeClipboardIsSupportedAlwaysTrue">
|
|
/// Only valid if <paramref name="autoInit"/> is true.
|
|
/// Only valid if <see cref="ConsoleDriver"/> == <see cref="FakeDriver"/> and <paramref name="autoInit"/> is true.
|
|
/// </param>
|
|
/// <param name="configLocation">
|
|
/// Determines what config file locations <see cref="ConfigurationManager"/> will
|
|
/// load from.
|
|
/// </param>
|
|
public AutoInitShutdownAttribute (bool autoInit = true,
|
|
Type consoleDriverType = null,
|
|
bool useFakeClipboard = true,
|
|
bool fakeClipboardAlwaysThrowsNotSupportedException = false,
|
|
bool fakeClipboardIsSupportedAlwaysTrue = false,
|
|
ConfigurationManager.ConfigLocations configLocation = ConfigurationManager.ConfigLocations.DefaultOnly)
|
|
{
|
|
AutoInit = autoInit;
|
|
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.GetCultureInfo ("en-US");
|
|
_driverType = consoleDriverType ?? typeof (FakeDriver);
|
|
FakeDriver.FakeBehaviors.UseFakeClipboard = useFakeClipboard;
|
|
FakeDriver.FakeBehaviors.FakeClipboardAlwaysThrowsNotSupportedException = fakeClipboardAlwaysThrowsNotSupportedException;
|
|
FakeDriver.FakeBehaviors.FakeClipboardIsSupportedAlwaysFalse = fakeClipboardIsSupportedAlwaysTrue;
|
|
ConfigurationManager.Locations = configLocation;
|
|
}
|
|
|
|
bool AutoInit { get; }
|
|
|
|
public override void Before (MethodInfo methodUnderTest)
|
|
{
|
|
Debug.WriteLine ($"Before: {methodUnderTest.Name}");
|
|
if (AutoInit) {
|
|
#if DEBUG_IDISPOSABLE
|
|
// Clear out any lingering Responder instances from previous tests
|
|
if (Responder.Instances.Count == 0) {
|
|
Assert.Empty (Responder.Instances);
|
|
} else {
|
|
Responder.Instances.Clear ();
|
|
}
|
|
#endif
|
|
Application.Init ((ConsoleDriver)Activator.CreateInstance (_driverType));
|
|
}
|
|
}
|
|
|
|
public override void After (MethodInfo methodUnderTest)
|
|
{
|
|
Debug.WriteLine ($"After: {methodUnderTest.Name}");
|
|
if (AutoInit) {
|
|
Application.Shutdown ();
|
|
#if DEBUG_IDISPOSABLE
|
|
if (Responder.Instances.Count == 0) {
|
|
Assert.Empty (Responder.Instances);
|
|
} else {
|
|
Responder.Instances.Clear ();
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
[AttributeUsage (AttributeTargets.Class | AttributeTargets.Method)]
|
|
public class TestRespondersDisposed : BeforeAfterTestAttribute {
|
|
public TestRespondersDisposed () => CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.GetCultureInfo ("en-US");
|
|
|
|
public override void Before (MethodInfo methodUnderTest)
|
|
{
|
|
Debug.WriteLine ($"Before: {methodUnderTest.Name}");
|
|
#if DEBUG_IDISPOSABLE
|
|
// Clear out any lingering Responder instances from previous tests
|
|
Responder.Instances.Clear ();
|
|
Assert.Empty (Responder.Instances);
|
|
#endif
|
|
}
|
|
|
|
public override void After (MethodInfo methodUnderTest)
|
|
{
|
|
Debug.WriteLine ($"After: {methodUnderTest.Name}");
|
|
#if DEBUG_IDISPOSABLE
|
|
Assert.Empty (Responder.Instances);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
[AttributeUsage (AttributeTargets.Class | AttributeTargets.Method)]
|
|
public class SetupFakeDriverAttribute : BeforeAfterTestAttribute {
|
|
/// <summary>
|
|
/// Enables test functions annotated with the [SetupFakeDriver] attribute to
|
|
/// set Application.Driver to new FakeDriver(). The driver is setup with
|
|
/// 10 rows and columns.
|
|
/// </summary>
|
|
public SetupFakeDriverAttribute () { }
|
|
|
|
public override void Before (MethodInfo methodUnderTest)
|
|
{
|
|
Debug.WriteLine ($"Before: {methodUnderTest.Name}");
|
|
Assert.Null (Application.Driver);
|
|
Application.Driver = new FakeDriver () { Rows = 10, Cols = 10 };
|
|
}
|
|
|
|
public override void After (MethodInfo methodUnderTest)
|
|
{
|
|
Debug.WriteLine ($"After: {methodUnderTest.Name}");
|
|
Application.Driver = null;
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
|
|
public class TestDateAttribute : Xunit.Sdk.BeforeAfterTestAttribute
|
|
{
|
|
CultureInfo _currentCulture = CultureInfo.CurrentCulture;
|
|
|
|
public TestDateAttribute()
|
|
{
|
|
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
|
|
}
|
|
|
|
public override void Before(MethodInfo methodUnderTest)
|
|
{
|
|
Assert.Equal(CultureInfo.CurrentCulture, CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
public override void After(MethodInfo methodUnderTest)
|
|
{
|
|
CultureInfo.CurrentCulture = _currentCulture;
|
|
Assert.Equal(CultureInfo.CurrentCulture, _currentCulture);
|
|
}
|
|
}
|
|
|
|
partial class TestHelpers {
|
|
[GeneratedRegex ("\\s+$", RegexOptions.Multiline)]
|
|
private static partial Regex TrailingWhiteSpaceRegEx ();
|
|
|
|
[GeneratedRegex ("^\\s+", RegexOptions.Multiline)]
|
|
private static partial Regex LeadingWhitespaceRegEx ();
|
|
|
|
public static string DriverContentsToString (ConsoleDriver driver = null)
|
|
{
|
|
var sb = new StringBuilder ();
|
|
driver ??= Application.Driver;
|
|
|
|
var contents = driver.Contents;
|
|
|
|
for (var r = 0; r < driver.Rows; r++) {
|
|
for (var c = 0; c < driver.Cols; c++) {
|
|
var rune = contents [r, c].Rune;
|
|
if (rune.DecodeSurrogatePair (out var sp)) {
|
|
sb.Append (sp);
|
|
} else {
|
|
sb.Append ((char)rune.Value);
|
|
}
|
|
if (rune.GetColumns () > 1) {
|
|
c++;
|
|
}
|
|
// See Issue #2616
|
|
//foreach (var combMark in contents [r, c].CombiningMarks) {
|
|
// sb.Append ((char)combMark.Value);
|
|
//}
|
|
}
|
|
sb.AppendLine ();
|
|
}
|
|
|
|
return sb.ToString ();
|
|
}
|
|
|
|
#pragma warning disable xUnit1013 // Public method should be marked as test
|
|
/// <summary>
|
|
/// Asserts that the driver contents match the expected contents, optionally ignoring any trailing whitespace.
|
|
/// </summary>
|
|
/// <param name="expectedLook"></param>
|
|
/// <param name="output"></param>
|
|
/// <param name="driver">The ConsoleDriver to use. If null <see cref="Application.Driver"/> will be used.</param>
|
|
/// <param name="ignoreLeadingWhitespace"></param>
|
|
public static void AssertDriverContentsAre (string expectedLook, ITestOutputHelper output, ConsoleDriver driver = null, bool ignoreLeadingWhitespace = false)
|
|
{
|
|
#pragma warning restore xUnit1013 // Public method should be marked as test
|
|
var actualLook = DriverContentsToString (driver);
|
|
|
|
if (string.Equals (expectedLook, actualLook)) {
|
|
return;
|
|
}
|
|
|
|
// get rid of trailing whitespace on each line (and leading/trailing whitespace of start/end of full string)
|
|
expectedLook = TrailingWhiteSpaceRegEx ().Replace (expectedLook, "").Trim ();
|
|
actualLook = TrailingWhiteSpaceRegEx ().Replace (actualLook, "").Trim ();
|
|
|
|
if (ignoreLeadingWhitespace) {
|
|
expectedLook = LeadingWhitespaceRegEx ().Replace (expectedLook, "").Trim ();
|
|
actualLook = LeadingWhitespaceRegEx ().Replace (actualLook, "").Trim ();
|
|
}
|
|
|
|
// standardize line endings for the comparison
|
|
expectedLook = expectedLook.Replace ("\r\n", "\n");
|
|
actualLook = actualLook.Replace ("\r\n", "\n");
|
|
|
|
// If test is about to fail show user what things looked like
|
|
if (!string.Equals (expectedLook, actualLook)) {
|
|
output?.WriteLine ("Expected:" + Environment.NewLine + expectedLook);
|
|
output?.WriteLine (" But Was:" + Environment.NewLine + actualLook);
|
|
}
|
|
|
|
Assert.Equal (expectedLook, actualLook);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Asserts that the driver contents are equal to the expected look, and that the cursor is at the expected position.
|
|
/// </summary>
|
|
/// <param name="expectedLook"></param>
|
|
/// <param name="output"></param>
|
|
/// <param name="driver">The ConsoleDriver to use. If null <see cref="Application.Driver"/> will be used.</param>
|
|
/// <returns></returns>
|
|
public static Rect AssertDriverContentsWithFrameAre (string expectedLook, ITestOutputHelper output, ConsoleDriver driver = null)
|
|
{
|
|
var lines = new List<List<Rune>> ();
|
|
var sb = new StringBuilder ();
|
|
driver ??= Application.Driver;
|
|
var x = -1;
|
|
var y = -1;
|
|
var w = -1;
|
|
var h = -1;
|
|
|
|
var contents = driver.Contents;
|
|
|
|
for (var r = 0; r < driver.Rows; r++) {
|
|
var runes = new List<Rune> ();
|
|
for (var c = 0; c < driver.Cols; c++) {
|
|
var rune = contents [r, c].Rune;
|
|
if (rune != (Rune)' ') {
|
|
if (x == -1) {
|
|
x = c;
|
|
y = r;
|
|
for (var i = 0; i < c; i++) {
|
|
runes.InsertRange (i, new List<Rune> { (Rune)' ' });
|
|
}
|
|
}
|
|
if (rune.GetColumns () > 1) {
|
|
c++;
|
|
}
|
|
if (c + 1 > w) {
|
|
w = c + 1;
|
|
}
|
|
h = r - y + 1;
|
|
}
|
|
if (x > -1) {
|
|
runes.Add (rune);
|
|
}
|
|
// See Issue #2616
|
|
//foreach (var combMark in contents [r, c].CombiningMarks) {
|
|
// runes.Add (combMark);
|
|
//}
|
|
}
|
|
if (runes.Count > 0) {
|
|
lines.Add (runes);
|
|
}
|
|
}
|
|
|
|
// Remove unnecessary empty lines
|
|
if (lines.Count > 0) {
|
|
for (var r = lines.Count - 1; r > h - 1; r--) {
|
|
lines.RemoveAt (r);
|
|
}
|
|
}
|
|
|
|
// Remove trailing whitespace on each line
|
|
foreach (var row in lines) {
|
|
for (var c = row.Count - 1; c >= 0; c--) {
|
|
var rune = row [c];
|
|
if (rune != (Rune)' ' || row.Sum (x => x.GetColumns ()) == w) {
|
|
break;
|
|
}
|
|
row.RemoveAt (c);
|
|
}
|
|
}
|
|
|
|
// Convert Rune list to string
|
|
for (var r = 0; r < lines.Count; r++) {
|
|
var line = StringExtensions.ToString (lines [r]);
|
|
if (r == lines.Count - 1) {
|
|
sb.Append (line);
|
|
} else {
|
|
sb.AppendLine (line);
|
|
}
|
|
}
|
|
|
|
var actualLook = sb.ToString ();
|
|
|
|
if (string.Equals (expectedLook, actualLook)) {
|
|
return new Rect (x > -1 ? x : 0, y > -1 ? y : 0, w > -1 ? w : 0, h > -1 ? h : 0);
|
|
}
|
|
|
|
// standardize line endings for the comparison
|
|
expectedLook = expectedLook.Replace ("\r\n", "\n");
|
|
actualLook = actualLook.Replace ("\r\n", "\n");
|
|
|
|
// Remove the first and the last line ending from the expectedLook
|
|
if (expectedLook.StartsWith ("\n")) {
|
|
expectedLook = expectedLook [1..];
|
|
}
|
|
if (expectedLook.EndsWith ("\n")) {
|
|
expectedLook = expectedLook [..^1];
|
|
}
|
|
|
|
output?.WriteLine ("Expected:" + Environment.NewLine + expectedLook);
|
|
output?.WriteLine (" But Was:" + Environment.NewLine + actualLook);
|
|
|
|
Assert.Equal (expectedLook, actualLook);
|
|
return new Rect (x > -1 ? x : 0, y > -1 ? y : 0, w > -1 ? w : 0, h > -1 ? h : 0);
|
|
}
|
|
|
|
#pragma warning disable xUnit1013 // Public method should be marked as test
|
|
/// <summary>
|
|
/// Verifies the console was rendered using the given <paramref name="expectedAttribute"/> at the given locations.
|
|
/// Pass a bitmap of indexes into <paramref name="expectedAttribute"/> as <paramref name="expectedLook"/> and the
|
|
/// test method will verify those colors were used in the row/col of the console during rendering
|
|
/// </summary>
|
|
/// <param name="expectedLook">
|
|
/// Numbers between 0 and 9 for each row/col of the console. Must be valid indexes of
|
|
/// <paramref name="expectedAttribute"/>
|
|
/// </param>
|
|
/// <param name="driver">The ConsoleDriver to use. If null <see cref="Application.Driver"/> will be used.</param>
|
|
/// <param name="expectedAttribute"></param>
|
|
public static void AssertDriverAttributesAre (string expectedLook, ConsoleDriver driver = null, params Attribute [] expectedAttribute)
|
|
{
|
|
#pragma warning restore xUnit1013 // Public method should be marked as test
|
|
|
|
if (expectedAttribute.Length > 10) {
|
|
throw new ArgumentException ("This method only works for UIs that use at most 10 colors");
|
|
}
|
|
|
|
expectedLook = expectedLook.Trim ();
|
|
driver ??= Application.Driver;
|
|
|
|
var contents = driver.Contents;
|
|
|
|
var line = 0;
|
|
foreach (var lineString in expectedLook.Split ('\n').Select (l => l.Trim ())) {
|
|
|
|
for (var c = 0; c < lineString.Length; c++) {
|
|
|
|
var val = contents [line, c].Attribute;
|
|
|
|
var match = expectedAttribute.Where (e => e == val).ToList ();
|
|
switch (match.Count) {
|
|
case 0:
|
|
throw new Exception ($"{DriverContentsToString (driver)}\n" +
|
|
$"Expected Attribute {val} at Contents[{line},{c}] {contents [line, c]}' was not found.\n" +
|
|
$" Expected: {string.Join (",", expectedAttribute.Select (c => c))}\n" +
|
|
$" But Was: <not found>");
|
|
case > 1:
|
|
throw new ArgumentException ($"Bad value for expectedColors, {match.Count} Attributes had the same Value");
|
|
}
|
|
|
|
var colorUsed = Array.IndexOf (expectedAttribute, match [0]).ToString () [0];
|
|
var userExpected = lineString [c];
|
|
|
|
if (colorUsed != userExpected) {
|
|
throw new Exception ($"{DriverContentsToString (driver)}\n" +
|
|
$"Unexpected Attribute at Contents[{line},{c}] {contents [line, c]}.'\n" +
|
|
$" Expected: {userExpected} ({expectedAttribute [int.Parse (userExpected.ToString ())]})\n" +
|
|
$" But Was: {colorUsed} ({val})\n");
|
|
}
|
|
}
|
|
|
|
line++;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifies the console used all the <paramref name="expectedColors"/> when rendering.
|
|
/// If one or more of the expected colors are not used then the failure will output both
|
|
/// the colors that were found to be used and which of your expectations was not met.
|
|
/// </summary>
|
|
/// <param name="driver">if null uses <see cref="Application.Driver"/></param>
|
|
/// <param name="expectedColors"></param>
|
|
internal static void AssertDriverUsedColors (ConsoleDriver driver = null, params Attribute [] expectedColors)
|
|
{
|
|
driver ??= Application.Driver;
|
|
var contents = driver.Contents;
|
|
|
|
var toFind = expectedColors.ToList ();
|
|
|
|
// Contents 3rd column is an Attribute
|
|
var colorsUsed = new HashSet<Attribute> ();
|
|
|
|
for (var r = 0; r < driver.Rows; r++) {
|
|
for (var c = 0; c < driver.Cols; c++) {
|
|
var val = contents [r, c].Attribute;
|
|
if (val.HasValue) {
|
|
colorsUsed.Add (val.Value);
|
|
|
|
var match = toFind.FirstOrDefault (e => e == val);
|
|
|
|
// need to check twice because Attribute is a struct and therefore cannot be null
|
|
if (toFind.Any (e => e == val)) {
|
|
toFind.Remove (match);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!toFind.Any ()) {
|
|
return;
|
|
}
|
|
var sb = new StringBuilder ();
|
|
sb.AppendLine ("The following colors were not used:" + string.Join ("; ", toFind.Select (a => a.ToString ())));
|
|
sb.AppendLine ("Colors used were:" + string.Join ("; ", colorsUsed.Select (a => a.ToString ())));
|
|
throw new Exception (sb.ToString ());
|
|
}
|
|
|
|
#pragma warning disable xUnit1013 // Public method should be marked as test
|
|
/// <summary>
|
|
/// Verifies two strings are equivalent. If the assert fails, output will be generated to standard
|
|
/// output showing the expected and actual look.
|
|
/// </summary>
|
|
/// <param name="output"></param>
|
|
/// <param name="expectedLook">
|
|
/// A string containing the expected look. Newlines should be specified as "\r\n" as
|
|
/// they will be converted to <see cref="Environment.NewLine"/> to make tests platform independent.
|
|
/// </param>
|
|
/// <param name="actualLook"></param>
|
|
public static void AssertEqual (ITestOutputHelper output, string expectedLook, string actualLook)
|
|
{
|
|
// Convert newlines to platform-specific newlines
|
|
expectedLook = ReplaceNewLinesToPlatformSpecific (expectedLook);
|
|
|
|
// If test is about to fail show user what things looked like
|
|
if (!string.Equals (expectedLook, actualLook)) {
|
|
output?.WriteLine ("Expected:" + Environment.NewLine + expectedLook);
|
|
output?.WriteLine (" But Was:" + Environment.NewLine + actualLook);
|
|
}
|
|
|
|
Assert.Equal (expectedLook, actualLook);
|
|
}
|
|
#pragma warning restore xUnit1013 // Public method should be marked as test
|
|
|
|
static string ReplaceNewLinesToPlatformSpecific (string toReplace)
|
|
{
|
|
var replaced = toReplace;
|
|
|
|
replaced = Environment.NewLine.Length switch {
|
|
2 when !replaced.Contains ("\r\n") => replaced.Replace ("\n", Environment.NewLine),
|
|
1 => replaced.Replace ("\r\n", Environment.NewLine),
|
|
var _ => replaced
|
|
};
|
|
|
|
return replaced;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a list of instances of all classes derived from View.
|
|
/// </summary>
|
|
/// <returns>List of View objects</returns>
|
|
public static List<View> GetAllViews () => typeof (View).Assembly.GetTypes ()
|
|
.Where (type => type.IsClass && !type.IsAbstract && type.IsPublic && type.IsSubclassOf (typeof (View)))
|
|
.Select (type => GetTypeInitializer (type, type.GetConstructor (Array.Empty<Type> ()))).ToList ();
|
|
|
|
static View GetTypeInitializer (Type type, ConstructorInfo ctor)
|
|
{
|
|
View viewType = null;
|
|
|
|
if (type.IsGenericType && type.IsTypeDefinition) {
|
|
var gTypes = new List<Type> ();
|
|
|
|
foreach (var args in type.GetGenericArguments ()) {
|
|
gTypes.Add (typeof (object));
|
|
}
|
|
type = type.MakeGenericType (gTypes.ToArray ());
|
|
|
|
Assert.IsType (type, (View)Activator.CreateInstance (type));
|
|
|
|
} else {
|
|
var paramsInfo = ctor.GetParameters ();
|
|
Type paramType;
|
|
var pTypes = new List<object> ();
|
|
|
|
if (type.IsGenericType) {
|
|
foreach (var args in type.GetGenericArguments ()) {
|
|
paramType = args.GetType ();
|
|
if (args.Name == "T") {
|
|
pTypes.Add (typeof (object));
|
|
} else {
|
|
AddArguments (paramType, pTypes);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var p in paramsInfo) {
|
|
paramType = p.ParameterType;
|
|
if (p.HasDefaultValue) {
|
|
pTypes.Add (p.DefaultValue);
|
|
} else {
|
|
AddArguments (paramType, pTypes);
|
|
}
|
|
|
|
}
|
|
|
|
if (type.IsGenericType && !type.IsTypeDefinition) {
|
|
viewType = (View)Activator.CreateInstance (type);
|
|
Assert.IsType (type, viewType);
|
|
} else {
|
|
viewType = (View)ctor.Invoke (pTypes.ToArray ());
|
|
Assert.IsType (type, viewType);
|
|
}
|
|
}
|
|
|
|
|
|
return viewType;
|
|
}
|
|
|
|
static void AddArguments (Type paramType, List<object> pTypes)
|
|
{
|
|
if (paramType == typeof (Rect)) {
|
|
pTypes.Add (Rect.Empty);
|
|
} else if (paramType == typeof (string)) {
|
|
pTypes.Add (string.Empty);
|
|
} else if (paramType == typeof (int)) {
|
|
pTypes.Add (0);
|
|
} else if (paramType == typeof (bool)) {
|
|
pTypes.Add (true);
|
|
} else if (paramType.Name == "IList") {
|
|
pTypes.Add (new List<object> ());
|
|
} else if (paramType.Name == "View") {
|
|
var top = new Toplevel ();
|
|
var view = new View ();
|
|
top.Add (view);
|
|
pTypes.Add (view);
|
|
} else if (paramType.Name == "View[]") {
|
|
pTypes.Add (new View [] { });
|
|
} else if (paramType.Name == "Stream") {
|
|
pTypes.Add (new MemoryStream ());
|
|
} else if (paramType.Name == "String") {
|
|
pTypes.Add (string.Empty);
|
|
} else if (paramType.Name == "TreeView`1[T]") {
|
|
pTypes.Add (string.Empty);
|
|
} else {
|
|
pTypes.Add (null);
|
|
}
|
|
}
|
|
} |