// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Reflection;
|
using System.Xml.Serialization;
|
using NUnit.Framework;
|
|
namespace OpenTap.Engine.UnitTests.UnitTestUtils
|
{
|
/// <summary>
|
/// This class can test INotifyPropertyChanged types and make sure that the setters and getters behave correspondingly.
|
/// PropertyChanged events should always refer to an EXISTING property.
|
/// The event should NOT be invoked if the value is set to the current value.
|
/// </summary>
|
[TestFixture]
|
public class ValidatingObjectConformance
|
{
|
|
static bool validProp(PropertyInfo prop)
|
{
|
if (!(prop.CanRead && prop.CanWrite))
|
{
|
return false;
|
}
|
if (prop.HasAttribute<XmlIgnoreAttribute>())
|
{
|
return false;
|
}
|
|
if (prop.HasAttribute<BrowsableAttribute>())
|
{
|
if (prop.GetAttribute<BrowsableAttribute>().Browsable == false)
|
{
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
static object GetUniqueValue(Type genType)
|
{
|
try
|
{
|
Type finalType = genType;
|
if (genType.IsPrimitive)
|
{
|
if (genType.IsEnum)
|
{
|
var vals = Enum.GetValues(genType);
|
if (vals.Length > 1)
|
{
|
return vals.GetValue(1);
|
}
|
return vals.GetValue(0);
|
}
|
if (genType == typeof(string))
|
{
|
return "..";
|
}
|
//126 random value. The works with most types.
|
return Convert.ChangeType(126, genType);
|
}
|
else if (genType.IsInterface || genType.IsAbstract)
|
{
|
var iface = PluginManager.GetPlugins(genType)
|
.FirstOrDefault(item => !item.IsInterface);
|
finalType = iface;
|
}
|
else if (genType == typeof(string))
|
{
|
return new Guid().ToString();
|
}
|
else if (genType.IsArray)
|
{
|
var elemType = genType.GetElementType();
|
var outarr = Array.CreateInstance(elemType, 1);
|
outarr.SetValue(GetUniqueValue(elemType), 0);
|
return outarr;
|
|
}
|
|
|
return Activator.CreateInstance(finalType);
|
}
|
catch (Exception)
|
{
|
return null;
|
}
|
}
|
|
|
static bool propertyChangedOk(Type holder, PropertyChangedEventArgs args)
|
{
|
string propStr = args.PropertyName;
|
if (String.IsNullOrEmpty(propStr))
|
{
|
return true;
|
}
|
foreach (string subStr in propStr.Split(','))
|
{
|
var prop = holder.GetProperty(subStr);
|
if (null == prop || !prop.CanRead)
|
{
|
return false;
|
}
|
}
|
return true;
|
|
}
|
|
public class ErrorPropException : Exception
|
{
|
public ErrorPropException(string msg)
|
: base(msg)
|
{
|
|
}
|
}
|
|
public class WarningPropException : ErrorPropException
|
{
|
public WarningPropException(string msg) : base(msg)
|
{
|
|
}
|
}
|
|
static public List<Exception> testTypeProperties(Type tp)
|
{
|
List<Exception> ex = new List<Exception>();
|
if (!tp.IsClass || !tp.HasInterface<INotifyPropertyChanged>())
|
{
|
return ex;
|
}
|
|
var properties = tp.GetProperties(BindingFlags.Instance
|
| BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.NonPublic)
|
.Where(validProp).ToArray();
|
|
if (properties.Length == 0)
|
{
|
return ex;
|
}
|
INotifyPropertyChanged instance;
|
try
|
{
|
instance = (INotifyPropertyChanged)Activator.CreateInstance(tp);
|
}
|
catch (Exception)
|
{
|
return ex;
|
}
|
instance.PropertyChanged += (s, e) =>
|
{
|
if (!propertyChangedOk(tp, e))
|
{
|
throw new ErrorPropException(String.Format("Property '{0}' does not exist on type '{1}'.", e.PropertyName, tp.FullName));
|
}
|
};
|
|
bool shouldNotChange = false;
|
|
instance.PropertyChanged += (s, e) =>
|
{
|
|
if (shouldNotChange)
|
{
|
throw new WarningPropException(String.Format("Event invoked even when value is the same. Property: '{0}' Type: '{1}'", e.PropertyName, tp.FullName));
|
}
|
};
|
|
foreach (var prop in properties)
|
{
|
try
|
{
|
prop.SetValue(instance, GetUniqueValue(prop.PropertyType), null);
|
|
//Test set/get same value
|
shouldNotChange = true;
|
prop.SetValue(instance, prop.GetValue(instance, null), null);
|
shouldNotChange = false;
|
}
|
catch (Exception _ex)
|
{
|
if (_ex.InnerException is ErrorPropException)
|
{
|
ex.Add(_ex.InnerException);
|
}
|
}
|
}
|
|
return ex;
|
}
|
|
[Test, Ignore("This will generate false positives.")]
|
public void TestINotifyPropertyChanged()
|
{
|
List<Exception> exceptions = new List<Exception>();
|
foreach (var type in PluginManager.GetPlugins<INotifyPropertyChanged>())
|
{
|
exceptions.AddRange(testTypeProperties(type));
|
}
|
if (exceptions.Any())
|
{
|
var warnings = exceptions.Where(ex => ex is WarningPropException);
|
warnings.ForEach(ex =>
|
{
|
Debug.Print("Warning: " + ex.Message);
|
});
|
var errors = exceptions.Where(ex => !(ex is WarningPropException)).ToList();
|
if (errors.Count > 0)
|
{
|
throw new AggregateException(errors);
|
}
|
}
|
}
|
|
public static void TestAssembly(Assembly asm)
|
{
|
List<Exception> exceptions = new List<Exception>();
|
|
foreach (var type in asm.GetTypes())
|
{
|
exceptions.AddRange(testTypeProperties(type));
|
}
|
if (exceptions.Any())
|
{
|
var warnings = exceptions.Where(ex => ex is WarningPropException);
|
warnings.ForEach(ex =>
|
{
|
Debug.Print("Warning: " + ex.Message);
|
});
|
var errors = exceptions.Where(ex => !(ex is WarningPropException)).ToList();
|
if (errors.Count > 0)
|
{
|
throw new AggregateException(errors);
|
}
|
}
|
}
|
}
|
}
|
