private static Attribute[] HasAttributesImpl(Type attributeType, int expectedCount, MemberInfo target, string messageFormat, params object[] messageArgs)
{
Attribute[] result = GenericCollectionUtils.ToArray(GetAttributes(attributeType, target));
AssertionHelper.Verify(() =>
{
string message = null;
if (result.Length == 0)
{
message = "Expected the searched attribute to decorate the target object; but none was found.";
}
else if (expectedCount > 0 && result.Length != expectedCount)
{
message = String.Format("Expected to find {0} attribute instance{1} but found {2}.",
expectedCount, expectedCount > 1 ? "s" : String.Empty, result.Length);
}
if (message == null)
{
return(null);
}
return(new AssertionFailureBuilder(message)
.AddRawLabeledValue("Target Object", target)
.AddRawLabeledValue("Attribute Type", attributeType)
.SetMessage(messageFormat, messageArgs)
.ToAssertionFailure());
});
return(result);
}
/// <inheritdoc />
protected override IEnumerable <IDataItem> GetItemsImpl(ICollection <DataBinding> bindings, bool includeDynamicItems)
{
IDataProvider[] providers = GenericCollectionUtils.ToArray(DataSets);
int providerCount = providers.Length;
var bindingsPerProvider = new List <DataBinding> [providerCount];
for (int i = 0; i < providerCount; i++)
{
bindingsPerProvider[i] = new List <DataBinding>();
}
foreach (DataBinding binding in bindings)
{
ResolvedBinding resolvedBinding = ResolveBinding(binding);
if (resolvedBinding != null)
{
bindingsPerProvider[resolvedBinding.DataSetInfo.DataSetIndex].Add(resolvedBinding.Inner);
}
}
foreach (IList <IDataItem> itemList in strategy.Join(providers, bindingsPerProvider, includeDynamicItems))
{
yield return(new JoinedDataItem(this, itemList));
}
}
private static bool ParseImpl(string value, out ReportArchive reportArchive, bool throwOnFailure)
{
if (String.IsNullOrEmpty(value))
{
reportArchive = Normal;
return(true);
}
foreach (ReportArchive item in All)
{
if (item.Value.ToString().Equals(value, StringComparison.OrdinalIgnoreCase))
{
reportArchive = item;
return(true);
}
}
if (throwOnFailure)
{
string[] names = GenericCollectionUtils.ToArray(GenericCollectionUtils.Select(All, x => x.Value.ToString()));
throw new ArgumentException(String.Format("Invalid report archive mode '{0}'. It must be one of the following values: {1}.",
value, String.Join(", ", names)));
}
reportArchive = Normal;
return(false);
}
/// <summary>
/// Constructs an assertion failure.
/// </summary>
/// <param name="native">The native unmanged object describing the failure.</param>
/// <param name="stringResolver">A service to resolve unmanaged unicode strings.</param>
public MbUnitCppAssertionFailure(NativeAssertionFailure native, IStringResolver stringResolver)
{
description = stringResolver.GetString(native.DescriptionId);
message = stringResolver.GetString(native.MessageId);
hasActualValue = native.ActualValue.IsValid;
hasExpectedValue = native.ExpectedValue.IsValid;
hasUnexpectedValue = native.UnexpectedValue.IsValid;
line = native.Line;
if (hasActualValue)
{
actualValue = NativeValueParser.Parse(stringResolver.GetString(native.ActualValue.ValueId), native.ActualValue.ValueType);
}
if (hasExpectedValue)
{
expectedValue = NativeValueParser.Parse(stringResolver.GetString(native.ExpectedValue.ValueId), native.ExpectedValue.ValueType);
}
if (hasUnexpectedValue)
{
unexpectedValue = NativeValueParser.Parse(stringResolver.GetString(native.UnexpectedValue.ValueId), native.UnexpectedValue.ValueType);
}
diffing = hasActualValue && (native.ActualValue.ValueType == NativeValueType.String) &&
((hasExpectedValue && (native.ExpectedValue.ValueType == NativeValueType.String)) ||
(hasUnexpectedValue && (native.UnexpectedValue.ValueType == NativeValueType.String)));
extraLabeledValues = GenericCollectionUtils.ToArray(GetExtraLabeledValues(native, stringResolver));
}
private void InitializeAvailableReportTypes()
{
IReportManager reportManager = RuntimeAccessor.ServiceLocator.Resolve <IReportManager>();
types = new List <ReportFormatterTraits>(GenericCollectionUtils.Select(reportManager.FormatterHandles, x => x.GetTraits()));
typeNames = new List <string>(GenericCollectionUtils.Select(types, x => x.Name));
comboBoxOutputReportType.Items.AddRange(GenericCollectionUtils.ToArray(types));
}
/// <summary>
/// Creates a filter set consisting of a collection of rules.
/// </summary>
/// <param name="rules">The filter rules.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="rules"/> is null.</exception>
public FilterSet(ICollection <FilterRule <T> > rules)
{
if (rules == null || rules.Contains(null))
{
throw new ArgumentNullException("rules");
}
this.rules = GenericCollectionUtils.ToArray(rules);
}
/// <summary>
/// Creates an AND-filter.
/// </summary>
/// <param name="filters">The filters that must all jointly be matched.
/// If the list is empty, the filter matches everything.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="filters"/> is null.</exception>
public AndFilter(ICollection <Filter <T> > filters)
{
if (filters == null || filters.Contains(null))
{
throw new ArgumentNullException("filters");
}
this.filters = GenericCollectionUtils.ToArray(filters);
}
public IList <IPluginDescriptor> GetPlugins()
{
if (plugins == null)
{
plugins = new ReadOnlyCollection <IPluginDescriptor>(GenericCollectionUtils.ToArray(pluginsByPluginId.Values));
}
return(plugins);
}
public IList <IServiceDescriptor> GetServices()
{
if (services == null)
{
services = new ReadOnlyCollection <IServiceDescriptor>(GenericCollectionUtils.ToArray(servicesByServiceId.Values));
}
return(services);
}
public IList <IComponentDescriptor> GetComponents()
{
if (components == null)
{
components = new ReadOnlyCollection <IComponentDescriptor>(GenericCollectionUtils.ToArray(componentsByComponentId.Values));
}
return(components);
}
public KeyValuePair <string, string>[] GetMetadata(IStringResolver resolver)
{
if (metadata == null)
{
metadata = GenericCollectionUtils.ToArray(EnumerateMetadata(resolver));
}
return(metadata);
}
public PluginDescriptor(Registry registry, PluginRegistration pluginRegistration, IList <IPluginDescriptor> completePluginDependenciesCopy)
{
this.registry = registry;
pluginId = pluginRegistration.PluginId;
pluginTypeName = pluginRegistration.PluginTypeName;
baseDirectory = pluginRegistration.BaseDirectory;
pluginProperties = pluginRegistration.PluginProperties.Copy().AsReadOnly();
traitsProperties = pluginRegistration.TraitsProperties.Copy().AsReadOnly();
pluginHandlerFactory = pluginRegistration.PluginHandlerFactory;
assemblyBindings = new ReadOnlyCollection <AssemblyBinding>(GenericCollectionUtils.ToArray(pluginRegistration.AssemblyBindings));
pluginDependencies = new ReadOnlyCollection <IPluginDescriptor>(completePluginDependenciesCopy);
probingPaths = new ReadOnlyCollection <string>(GenericCollectionUtils.ToArray(pluginRegistration.ProbingPaths));
enableCondition = pluginRegistration.EnableCondition;
recommendedInstallationPath = pluginRegistration.RecommendedInstallationPath;
filePaths = new ReadOnlyCollection <string>(GenericCollectionUtils.ToArray(pluginRegistration.FilePaths));
}
private void ShowRegisteredComponents <T>(string heading, ICollection <T> handles, GallioFunc <T, string> getName, GallioFunc <T, string> getDescription)
{
Console.WriteLine(heading);
Console.WriteLine();
T[] sortedHandles = GenericCollectionUtils.ToArray(handles);
Array.Sort(sortedHandles, (x, y) => getName(x).CompareTo(getName(y)));
if (sortedHandles.Length == 0)
{
CommandLineOutput.PrintArgumentHelp("", "<none>", null, null, null, null);
}
else
{
foreach (T handle in sortedHandles)
{
CommandLineOutput.PrintArgumentHelp("", getName(handle), null, getDescription(handle), null, null);
Console.WriteLine();
}
}
}
/// <inheritdoc />
protected override IEnumerable <IDataItem> GetItemsImpl(ICollection <DataBinding> bindings, bool includeDynamicItems)
{
IDataProvider[] providers = GenericCollectionUtils.ToArray(DataSets);
return(strategy.Merge(providers, bindings, includeDynamicItems));
}
private void SortChildren(ManagedTestCommand parent, MultiMap <ManagedTestCommand, ManagedTestCommand> siblingDependencies)
{
ManagedTestCommand[] children = parent.ChildrenToArray();
if (children.Length == 0)
{
return;
}
// Clear the array of children since we are about to reshuffle them.
parent.ClearChildren();
// Sort the children by order. Because the topological sort emits vertices precisely
// in the ordert that it visits them (depth-first) it will preserve the relative ordering
// of independent vertices. So we influence test execution order by pre-sorting.
// Dependencies will of course interfere with the ordering slightly. However, if the
// user explicitly specifies orderings in dependency order then they'll indeed run in
// that specified order. -- Jeff.
SortCommandsByOrder(children);
// Perform a topological sort of the children using depth-first search.
// Because at this stage a command only has dependencies on its siblings the depth-first search
// actually proceeds down the chain of sibling dependencies only; it does not
// traverse the whole test hierarchy. -- Jeff.
Dictionary <ManagedTestCommand, bool> visitedSet = new Dictionary <ManagedTestCommand, bool>();
Stack <DepthFirstEntry> stack = new Stack <DepthFirstEntry>();
stack.Push(new DepthFirstEntry(null, children));
for (;;)
{
DepthFirstEntry top = stack.Peek();
if (top.DependencyEnumerator.MoveNext())
{
ManagedTestCommand current = top.DependencyEnumerator.Current;
bool inProgressFlag;
if (visitedSet.TryGetValue(current, out inProgressFlag))
{
if (inProgressFlag)
{
throw new ModelException(String.Format("Found a test dependency cycle involving test '{0}'.",
current.Test.FullName));
}
}
else
{
IList <ManagedTestCommand> unorderedDependencies = siblingDependencies[current];
if (unorderedDependencies.Count != 0)
{
visitedSet[current] = true;
// We need to sort all visited children so that dependencies run in relative order.
ManagedTestCommand[] dependencies = GenericCollectionUtils.ToArray(unorderedDependencies);
SortCommandsByOrder(dependencies);
stack.Push(new DepthFirstEntry(current, dependencies));
}
else
{
parent.AddChild(current);
visitedSet[current] = false;
}
}
}
else
{
ManagedTestCommand current = top.Source;
if (current == null)
{
break;
}
parent.AddChild(current);
visitedSet[current] = false;
stack.Pop();
}
}
// Recursively sort the children of this command.
foreach (ManagedTestCommand child in children)
{
SortChildren(child, siblingDependencies);
}
}
/// <summary>
/// Reads the null-terminated ASCII string at the specified offset.
/// </summary>
/// <param name="offset">The offset from the beginning of the file.</param>
/// <returns>The string read at the specified position.</returns>
public string ReadAsciiString(long offset)
{
Seek(offset);
byte[] bytes = GenericCollectionUtils.ToArray(ReadBytes());
return(Encoding.ASCII.GetString(bytes));
}
private static void SetIronRubyLibraryPaths(LanguageSetup languageSetup, IList <string> libraryPaths)
{
languageSetup.Options["LibraryPaths"] = string.Join(";", GenericCollectionUtils.ToArray(libraryPaths));
}
public void AttributeWrapper(Type type, int index)
{
SampleAttribute target = (SampleAttribute)type.GetCustomAttributes(typeof(SampleAttribute), true)[index];
IAttributeInfo info = GenericCollectionUtils.ToArray(GetType(type).GetAttributeInfos(Reflector.Wrap(typeof(SampleAttribute)), true))[index];
WrapperAssert.AreEquivalent(target, info, false);
SampleAttribute resolvedAttrib = (SampleAttribute)info.Resolve(true);
Assert.AreEqual(target.param, resolvedAttrib.param);
Assert.AreEqual(target.Field, resolvedAttrib.Field);
Assert.AreEqual(target.Property, resolvedAttrib.Property);
try
{
WrapperAssert.AreEquivalent(typeof(SampleAttribute).GetConstructors()[0], info.Constructor, false);
}
catch (NotSupportedException)
{
// This is also acceptable behavior.
}
Dictionary <IFieldInfo, object> fieldValues = new Dictionary <IFieldInfo, object>();
foreach (KeyValuePair <IFieldInfo, ConstantValue> entry in info.InitializedFieldValues)
{
fieldValues.Add(entry.Key, entry.Value.Resolve(true));
}
Dictionary <IPropertyInfo, object> propertyValues = new Dictionary <IPropertyInfo, object>();
foreach (KeyValuePair <IPropertyInfo, ConstantValue> entry in info.InitializedPropertyValues)
{
propertyValues.Add(entry.Key, entry.Value.Resolve(true));
}
if (target.param == typeof(int))
{
try
{
object[] values = GenericCollectionUtils.ConvertAllToArray <ConstantValue, object>(info.InitializedArgumentValues,
delegate(ConstantValue constantValue) { return(constantValue.Resolve(true)); });
Assert.AreElementsEqual(new object[] { typeof(int) }, values);
}
catch (NotSupportedException)
{
// This is also acceptable behavior.
}
if (fieldValues.Count != 0)
{
Assert.AreEqual(1, fieldValues.Count, "The implementation may return values for uninitialized fields, but there is only one such field.");
Assert.AreEqual(0, fieldValues[GetField(typeof(SampleAttribute).GetField("Field"))]);
}
if (propertyValues.Count != 0)
{
Assert.AreEqual(1, propertyValues.Count, "The implementation may return values uninitialized properties, but there is only one such field.");
Assert.AreEqual(null, propertyValues[GetProperty(typeof(SampleAttribute).GetProperty("Property"))]);
}
}
else
{
try
{
object[] values = GenericCollectionUtils.ConvertAllToArray <ConstantValue, object>(info.InitializedArgumentValues,
delegate(ConstantValue constantValue) { return(constantValue.Resolve(true)); });
Assert.AreElementsEqual(new object[] { typeof(string[]) }, values);
}
catch (NotSupportedException)
{
// This is also acceptable behavior.
}
Assert.AreElementsEqual(new KeyValuePair <IFieldInfo, object>[] {
new KeyValuePair <IFieldInfo, object>(GetField(typeof(SampleAttribute).GetField("Field")), 2)
}, fieldValues);
Assert.AreElementsEqual(new KeyValuePair <IPropertyInfo, object>[] {
new KeyValuePair <IPropertyInfo, object>(GetProperty(typeof(SampleAttribute).GetProperty("Property")), "foo")
}, propertyValues);
}
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue(ContentsKey, GenericCollectionUtils.ToArray(this));
}
public static object[] GetCustomAttributes(ICodeElementInfo adapter, bool inherit)
{
return(GenericCollectionUtils.ToArray(adapter.GetAttributes(null, inherit)));
}
private static TAttribute[] ToAttributeArray <TAttribute>(Attribute[] attributes)
where TAttribute : Attribute
{
return(GenericCollectionUtils.ToArray(GenericCollectionUtils.Select(attributes, x => (TAttribute)x)));
}
public static object[] GetCustomAttributes(ICodeElementInfo adapter, Type attributeType, bool inherit)
{
return(GenericCollectionUtils.ToArray(adapter.GetAttributes(Reflector.Wrap(attributeType), inherit)));
}
