test/Tizen.NUI.Devel.Tests.Ubuntu/nunit.framework/Internal/Builders/DatapointProvider.cs

   1 // ***********************************************************************
   2 // Copyright (c) 2008 Charlie Poole
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 // ***********************************************************************
  23 #define PORTABLE
  24 #define TIZEN
  25 #define NUNIT_FRAMEWORK
  26 #define NUNITLITE
  27 #define NET_4_5
  28 #define PARALLEL
  29 using System;
  30 using System.Reflection;
  31 using System.Collections;
  32 using System.Collections.Generic;
  33 using NUnit.Compatibility;
  34 using NUnit.Framework.Interfaces;
  35
  36 namespace NUnit.Framework.Internal.Builders
  37 {
  38     /// <summary>
  39     /// Provides data from fields marked with the DatapointAttribute or the
  40     /// DatapointsAttribute.
  41     /// </summary>
  42     public class DatapointProvider : IParameterDataProvider
  43     {
  44         #region IDataPointProvider Members
  45
  46         /// <summary>
  47         /// Determine whether any data is available for a parameter.
  48         /// </summary>
  49         /// <param name="parameter">A ParameterInfo representing one
  50         /// argument to a parameterized test</param>
  51         /// <returns>
  52         /// True if any data is available, otherwise false.
  53         /// </returns>
  54         public bool HasDataFor(IParameterInfo parameter)
  55         {
  56             var method = parameter.Method;
  57             if (!method.IsDefined<TheoryAttribute>(true))
  58                 return false;
  59
  60             Type parameterType = parameter.ParameterType;
  61             if (parameterType == typeof(bool) || parameterType.GetTypeInfo().IsEnum)
  62                 return true;
  63
  64             Type containingType = method.TypeInfo.Type;
  65             foreach (MemberInfo member in containingType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy))
  66             {
  67                 if (member.IsDefined(typeof(DatapointAttribute), true) &&
  68                     GetTypeFromMemberInfo(member) == parameterType)
  69                         return true;
  70                 else if (member.IsDefined(typeof(DatapointSourceAttribute), true) &&
  71                     GetElementTypeFromMemberInfo(member) == parameterType)
  72                     return true;
  73             }
  74
  75             return false;
  76         }
  77
  78         /// <summary>
  79         /// Return an IEnumerable providing data for use with the
  80         /// supplied parameter.
  81         /// </summary>
  82         /// <param name="parameter">A ParameterInfo representing one
  83         /// argument to a parameterized test</param>
  84         /// <returns>
  85         /// An IEnumerable providing the required data
  86         /// </returns>
  87         public System.Collections.IEnumerable GetDataFor(IParameterInfo parameter)
  88         {
  89             var datapoints = new List<object>();
  90
  91             Type parameterType = parameter.ParameterType;
  92             Type fixtureType = parameter.Method.TypeInfo.Type;
  93
  94             foreach (MemberInfo member in fixtureType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy))
  95             {
  96                 if (member.IsDefined(typeof(DatapointAttribute), true))
  97                 {
  98                     var field = member as FieldInfo;
  99                     if (GetTypeFromMemberInfo(member) == parameterType && field != null)
 100                     {
 101                         if (field.IsStatic)
 102                             datapoints.Add(field.GetValue(null));
 103                         else
 104                             datapoints.Add(field.GetValue(ProviderCache.GetInstanceOf(fixtureType)));
 105                     }
 106                 }
 107                 else if (member.IsDefined(typeof(DatapointSourceAttribute), true))
 108                 {
 109                     if (GetElementTypeFromMemberInfo(member) == parameterType)
 110                     {
 111                         object instance;
 112
 113                         FieldInfo field = member as FieldInfo;
 114                         PropertyInfo property = member as PropertyInfo;
 115                         MethodInfo method = member as MethodInfo;
 116                         if (field != null)
 117                         {
 118                             instance = field.IsStatic ? null : ProviderCache.GetInstanceOf(fixtureType);
 119                             foreach (object data in (IEnumerable)field.GetValue(instance))
 120                                 datapoints.Add(data);
 121                         }
 122                         else if (property != null)
 123                         {
 124                             MethodInfo getMethod = property.GetGetMethod(true);
 125                             instance = getMethod.IsStatic ? null : ProviderCache.GetInstanceOf(fixtureType);
 126                             foreach (object data in (IEnumerable)property.GetValue(instance, null))
 127                                 datapoints.Add(data);
 128                         }
 129                         else if (method != null)
 130                         {
 131                             instance = method.IsStatic ? null : ProviderCache.GetInstanceOf(fixtureType);
 132                             foreach (object data in (IEnumerable)method.Invoke(instance, new Type[0]))
 133                                 datapoints.Add(data);
 134                         }
 135                     }
 136                 }
 137             }
 138
 139             if (datapoints.Count == 0)
 140             {
 141                 if (parameterType == typeof(bool))
 142                 {
 143                     datapoints.Add(true);
 144                     datapoints.Add(false);
 145                 }
 146                 else if (parameterType.GetTypeInfo().IsEnum)
 147                 {
 148                     foreach (object o in TypeHelper.GetEnumValues(parameterType))
 149                         datapoints.Add(o);
 150                 }
 151             }
 152
 153             return datapoints;
 154         }
 155
 156         private Type GetTypeFromMemberInfo(MemberInfo member)
 157         {
 158             var field = member as FieldInfo;
 159             if (field != null)
 160                 return field.FieldType;
 161
 162             var property = member as PropertyInfo;
 163             if (property != null)
 164                 return property.PropertyType;
 165
 166             var method = member as MethodInfo;
 167             if (method != null)
 168                 return method.ReturnType;
 169
 170             return null;
 171         }
 172
 173         private Type GetElementTypeFromMemberInfo(MemberInfo member)
 174         {
 175             Type type = GetTypeFromMemberInfo(member);
 176
 177             if (type == null)
 178                 return null;
 179
 180             if (type.IsArray)
 181                 return type.GetElementType();
 182
 183             if (type.GetTypeInfo().IsGenericType && type.Name == "IEnumerable`1")
 184                 return type.GetGenericArguments()[0];
 185
 186             return null;
 187         }
 188
 189         #endregion
 190     }
 191 }