| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| namespace Apache.Ignite.Core.Tests |
| { |
| using System; |
| using System.Collections; |
| using System.Collections.Generic; |
| using System.Linq; |
| using NUnit.Framework; |
| |
| /// <summary> |
| /// NUnit assert extensions. |
| /// </summary> |
| internal static class AssertExtensions |
| { |
| /// <summary> |
| /// Asserts equality with reflection recursively. |
| /// </summary> |
| public static void ReflectionEqual(object x, object y, string propertyPath = null, |
| HashSet<string> ignoredProperties = null) |
| { |
| if (x == null && y == null) |
| { |
| return; |
| } |
| |
| Assert.IsNotNull(x, propertyPath); |
| Assert.IsNotNull(y, propertyPath); |
| |
| var type = x.GetType(); |
| |
| var isCollection = type != typeof(string) && typeof(IEnumerable).IsAssignableFrom(type); |
| if (isCollection) |
| { |
| var xCol = ((IEnumerable) x).OfType<object>().ToList(); |
| var yCol = ((IEnumerable) y).OfType<object>().ToList(); |
| |
| Assert.AreEqual(xCol.Count, yCol.Count, propertyPath); |
| |
| for (var i = 0; i < xCol.Count; i++) |
| { |
| ReflectionEqual(xCol[i], yCol[i], propertyPath, ignoredProperties); |
| } |
| |
| return; |
| } |
| |
| Assert.AreEqual(type, y.GetType()); |
| |
| propertyPath = propertyPath ?? type.Name; |
| |
| if (type.IsValueType || type == typeof(string) || type.IsSubclassOf(typeof(Type))) |
| { |
| if (type.IsGenericType) |
| { |
| Type baseType = type.GetGenericTypeDefinition(); |
| if (baseType == typeof(KeyValuePair<,>)) |
| { |
| ReflectionEqual( |
| GetReflectionValue(type, x, "Key"), |
| GetReflectionValue(type, y, "Key")); |
| ReflectionEqual( |
| GetReflectionValue(type, x, "Value"), |
| GetReflectionValue(type, y, "Value")); |
| return; |
| } |
| } |
| |
| Assert.AreEqual(x, y, propertyPath); |
| return; |
| } |
| |
| var props = type.GetProperties().Where(p => p.GetIndexParameters().Length == 0); |
| |
| foreach (var propInfo in props) |
| { |
| if (ignoredProperties != null && ignoredProperties.Contains(propInfo.Name)) |
| { |
| continue; |
| } |
| |
| var propName = propertyPath + "." + propInfo.Name; |
| |
| var xVal = propInfo.GetValue(x, null); |
| var yVal = propInfo.GetValue(y, null); |
| |
| ReflectionEqual(xVal, yVal, propName, ignoredProperties); |
| } |
| } |
| |
| /// <summary> |
| /// Gets property value using reflection. |
| /// </summary> |
| /// <param name="type">Type.</param> |
| /// <param name="obj">Object.</param> |
| /// <param name="propertyName">Property name.</param> |
| /// <returns>Value.</returns> |
| private static object GetReflectionValue(Type type, object obj, string propertyName) |
| { |
| // ReSharper disable once PossibleNullReferenceException |
| return type.GetProperty(propertyName).GetValue(obj, null); |
| } |
| } |
| } |