public static void Deconstruct <T>(
this T[] array,
out T item1,
out T item2,
out T item3,
out T item4,
out T item5,
out T item6,
out T item7,
out T item8,
out T item9,
out T item10)
{
Code.NotNull(array, nameof(array));
Code.AssertArgument(array.Length >= 10, nameof(array), _arrayTooShortMsg);
item1 = array[0];
item2 = array[1];
item3 = array[2];
item4 = array[3];
item5 = array[4];
item6 = array[5];
item7 = array[6];
item8 = array[7];
item9 = array[8];
item10 = array[9];
}
private static MetricUnit[] GetMetricUnits(Type metricEnumType)
{
var result = new List <MetricUnit>();
var fields = EnumHelper.GetEnumValues(metricEnumType)
.OrderBy(f => Convert.ToDouble(f.Value, CultureInfo.InvariantCulture));
MetricUnit previousUnit = null;
foreach (var field in fields)
{
var unit = GetMetricUnit(field.UnderlyingField);
if (previousUnit != null)
{
Code.AssertArgument(
previousUnit.AppliesFrom < unit.AppliesFrom,
nameof(metricEnumType),
$"The applies from value of {metricEnumType.Name}.{unit.EnumValue} ({unit.AppliesFrom.ToInvariantString()}) " +
$"should be greater than prev unit {metricEnumType.Name}.{previousUnit.EnumValue} value ({previousUnit.AppliesFrom.ToInvariantString()})");
}
previousUnit = unit;
result.Add(unit);
}
Code.AssertArgument(
result.Count > 0,
nameof(metricEnumType),
$"The enum {metricEnumType} should be not empty.");
return(result.ToArray());
}
/// <summary>Initializes a new instance of the <see cref="TargetSourceLines"/> class.</summary>
/// <param name="targetMethodHandle">Benchmark target method handle.</param>
/// <param name="primaryAttributeLineNumber">Number of source line that contain primary annotation attribute.</param>
/// <param name="attributeCandidateLineNumbers">Range of source lines that may contain attribute annotations.</param>
/// <param name="attributeLineNumbers">Source lines that contain attribute annotations.</param>
public TargetSourceLines(
RuntimeMethodHandle targetMethodHandle,
int primaryAttributeLineNumber,
Range <int> attributeCandidateLineNumbers,
Dictionary <RuntimeTypeHandle, int> attributeLineNumbers)
{
Code.InRange(primaryAttributeLineNumber, nameof(primaryAttributeLineNumber), 1, int.MaxValue);
Code.AssertArgument(
Range.Create(1, int.MaxValue).Contains(attributeCandidateLineNumbers),
nameof(attributeCandidateLineNumbers),
"Incorrect candidate line numbers range.");
Code.AssertArgument(
attributeCandidateLineNumbers.Contains(primaryAttributeLineNumber),
nameof(primaryAttributeLineNumber),
"Incorrect primery attribute line number.");
DebugCode.AssertArgument(
attributeLineNumbers.Values.All(l => attributeCandidateLineNumbers.Contains(l)),
nameof(attributeLineNumbers),
"Incorrect attribute line numbers.");
TargetMethodHandle = targetMethodHandle;
PrimaryAttributeLineNumber = primaryAttributeLineNumber;
AttributeCandidateLineNumbers = attributeCandidateLineNumbers;
_attributeLineNumbers = attributeLineNumbers;
}
public T Clamp(T value)
{
Code.AssertArgument(IsNotEmpty, nameof(value), "Cannot fit the value into empty range.");
Code.AssertArgument(
!From.IsExclusiveBoundary, nameof(value), "The clamp range boundary From is exclusive and has no value.");
Code.AssertArgument(
!To.IsExclusiveBoundary, nameof(value), "The clamp range boundary To is exclusive and has no value.");
// case for the positive infinity
if (!RangeBoundaryFrom <T> .IsValid(value))
{
if (To < RangeBoundaryTo <T> .PositiveInfinity)
{
return(To.Value);
}
return(value);
}
if (From > value)
{
return(From.Value);
}
if (To < value)
{
return(To.Value);
}
return(value);
}
/// <summary>Adjusts the specified value so that it fits into a range specified.</summary>
/// <typeparam name="T">The type of the range values.</typeparam>
/// <param name="range">The range the value will be fitted to.</param>
/// <param name="value">The value to be adjusted.</param>
/// <exception cref="ArgumentException">The range is empty or any of its boundaries is exclusive.</exception>
/// <returns>A new value that fits into a range specified</returns>
public static T Adjust <T>(this Range <T> range, T value)
{
Code.AssertArgument(
range.IsNotEmpty, nameof(range), "Cannot fit the value into empty range.");
Code.AssertArgument(
!range.From.IsExclusiveBoundary, nameof(range), "The boundary From is exclusive and has no value.");
Code.AssertArgument(
!range.To.IsExclusiveBoundary, nameof(range), "The boundary To is exclusive and has no value.");
// case for the positive infinity
if (!RangeBoundaryFrom <T> .IsValid(value))
{
if (range.To < RangeBoundaryTo <T> .PositiveInfinity)
{
return(range.To.Value);
}
return(value);
}
if (range.From > value)
{
return(range.From.Value);
}
if (range.To < value)
{
return(range.To.Value);
}
return(value);
}
/// <summary>Initializes a new instance of the <see cref="MetricUnit"/> class.</summary>
/// <param name="name">The name of the metric measurement unit.</param>
/// <param name="enumValue">Enum value for the measurement unit.</param>
/// <param name="scaleCoefficient">The scale coefficient for the metric measurement unit.</param>
/// <param name="appliesFrom">The apply threshold for the metric unit.</param>
/// <param name="roundingDigits">
/// Number of fractional digits for storing and comparing metric values
/// or <c>null</c> if auto-rounding feature shold be used.
/// </param>
internal MetricUnit(
[NotNull] string name,
[NotNull] Enum enumValue,
double scaleCoefficient,
double appliesFrom,
[CanBeNull] int?roundingDigits)
{
Code.NotNullNorEmpty(name, nameof(name));
Code.NotNull(enumValue, nameof(enumValue));
Code.AssertArgument(
scaleCoefficient > 0 && scaleCoefficient <= double.MaxValue,
nameof(scaleCoefficient),
"The scale coefficient has to be non-zero positive numeric value.");
Code.AssertArgument(
appliesFrom >= 0 && appliesFrom <= double.MaxValue,
nameof(appliesFrom),
"The applies from value has to be zero or positive numeric value.");
Code.InRange(roundingDigits ?? 0, nameof(roundingDigits), 0, MaxRoundingDigits);
DisplayName = name;
IsEmpty = false;
EnumValue = enumValue;
ScaleCoefficient = scaleCoefficient;
AppliesFrom = appliesFrom;
RoundingDigits = roundingDigits;
}
public static void Deconstruct <T>(
this IEnumerable <T> enumerable,
out T item1,
out T item2,
out T item3,
out T item4,
out T item5,
out T item6,
out T item7,
out T item8,
out T item9)
{
Code.NotNull(enumerable, nameof(enumerable));
using var enumerator = enumerable.GetEnumerator();
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item1 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item2 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item3 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item4 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item5 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item6 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item7 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item8 = enumerator.Current;
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item9 = enumerator.Current;
}
public static void Deconstruct <T>(
this IList <T> list,
out T item1,
out T item2,
out T item3,
out T item4,
out T item5,
out T item6,
out T item7,
out T item8,
out T item9,
out T item10)
{
Code.NotNull(list, nameof(list));
Code.AssertArgument(list.Count >= 10, nameof(list), _listTooShortMsg);
item1 = list[0];
item2 = list[1];
item3 = list[2];
item4 = list[3];
item5 = list[4];
item6 = list[5];
item7 = list[6];
item8 = list[7];
item9 = list[8];
item10 = list[9];
}
public static TableDataParser.Parser CreateParser([NotNull] int[] widths)
{
Code.NotNull(widths, nameof(widths));
Code.AssertArgument(widths.Length > 0, nameof(widths), "At least one column must be specified");
Code.AssertArgument(widths.All(w => w > 0), nameof(widths), "Column width must be greater than 0");
return((TextReader rdr, ref int ln) => Parse(rdr, ref ln, widths));
}
/// <summary>
/// Inserts an element into the <see cref="Collection{T}"/> at the specified index.
/// Sets owner for the items being added.
/// </summary>
/// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
/// <param name="item">The object to insert. The value can be null for reference types.</param>
protected override void InsertItem(int index, TItem item)
{
Code.NotNull(item, nameof(item));
Code.AssertArgument(GetOwner(item) == null, nameof(item), "Cannot add an item as it is mapped to another owner.");
base.InsertItem(index, item);
SetOwner(item, Owner);
}
/// <summary>Gets diagnosers the metric values.</summary>
/// <param name="metric">The metric to get diagnosers for.</param>
/// <returns>Diagnosers for the metric values</returns>
public IDiagnoser[] GetDiagnosers(MetricInfo metric)
{
Code.NotNull(metric, nameof(metric));
Code.AssertArgument(
metric.ValuesProvider == this, nameof(metric),
"Passed ValuesProvider does not match to this one.");
return(GetDiagnosersOverride(metric));
}
public static void Deconstruct <T>(
this T[] array,
out T item1)
{
Code.NotNull(array, nameof(array));
Code.AssertArgument(array.Length >= 1, nameof(array), _arrayTooShortMsg);
item1 = array[0];
}
public static void Deconstruct <T>(
this IList <T> list,
out T item1)
{
Code.NotNull(list, nameof(list));
Code.AssertArgument(list.Count >= 1, nameof(list), _listTooShortMsg);
item1 = list[0];
}
/// <summary>Gets column provider for the metric values.</summary>
/// <param name="metric">The metric to get column for.</param>
/// <returns>Column provider for the metric values</returns>
public IColumnProvider GetColumnProvider(MetricInfo metric)
{
Code.NotNull(metric, nameof(metric));
Code.AssertArgument(
metric.ValuesProvider == this, nameof(metric),
"Passed ValuesProvider does not match to this one.");
return(GetColumnProviderOverride(metric));
}
/// <summary>Adds target key for the document.</summary>
/// <param name="annotationDocument">The annotation document.</param>
/// <param name="key">The target key.</param>
public void AddTargetKey(AnnotationDocument annotationDocument, AnnotationTargetKey key)
{
Code.AssertArgument(
annotationDocument.Parsed &&
ReferenceEquals(annotationDocument.AnnotationContext, Owner),
nameof(annotationDocument),
"The document is not parsed or does not belongs to the context.");
_documentsByTargets.Add(key, annotationDocument);
}
/// <summary>Gets column provider for the metric values.</summary>
/// <param name="metric">The metric to get columns for.</param>
/// <param name="columns">The columns to include.</param>
/// <returns>Column provider for the metric values</returns>
public IColumnProvider GetColumnProvider(MetricInfo metric, MetricValueColumns columns)
{
Code.NotNull(metric, nameof(metric));
EnumCode.FlagsDefined(columns, nameof(columns));
Code.AssertArgument(
metric.ValuesProvider == this, nameof(metric),
"Passed ValuesProvider does not match to this one.");
return(GetColumnProviderOverride(metric, columns));
}
public static void Deconstruct <T>(
this IEnumerable <T> enumerable,
out T item1)
{
Code.NotNull(enumerable, nameof(enumerable));
using var enumerator = enumerable.GetEnumerator();
Code.AssertArgument(enumerator.MoveNext(), nameof(enumerable), _enumTooShortMsg);
item1 = enumerator.Current;
}
public void TestAssertArgument()
{
var ex = Assert.Throws <ArgumentException>(
() => Code.AssertArgument(false, "arg00", "someUniqueMessage {0}", "someUniqueFormatArg"));
Assert.That(ex.Message, Does.Contain("arg00"));
Assert.That(ex.Message, Does.Contain("someUniqueMessage"));
Assert.That(ex.Message, Does.Contain("someUniqueFormatArg"));
Assert.DoesNotThrow(() => Code.AssertArgument(true, "arg00", "someUniqueMessage"));
}
/// <summary>
/// Replaces the element at the specified index.
/// Sets owner for the items being added.
/// Clears owner for the item being removed.
/// </summary>
/// <param name="index">The zero-based index of the element to replace.</param>
/// <param name="item">
/// The new value for the element at the specified index. The value can be null for reference types.
/// </param>
protected override void SetItem(int index, TItem item)
{
Code.NotNull(item, nameof(item));
Code.AssertArgument(GetOwner(item) == null, nameof(item), "Cannot add an item as it is mapped to another owner.");
var oldItem = this[index];
Code.BugIf(oldItem == null, "One of items in collection is null.");
SetOwner(oldItem, null);
base.SetItem(index, item);
SetOwner(item, Owner);
}
public static void Deconstruct <T>(
[NotNull] this T[] array,
out T item1,
out T item2,
out T item3)
{
Code.NotNull(array, nameof(array));
Code.AssertArgument(array.Length >= 3, nameof(array), _arrayTooShortMsg);
item1 = array[0];
item2 = array[1];
item3 = array[2];
}
public static void Deconstruct <T>(
[NotNull] this IList <T> list,
out T item1,
out T item2,
out T item3)
{
Code.NotNull(list, nameof(list));
Code.AssertArgument(list.Count >= 3, nameof(list), _listTooShortMsg);
item1 = list[0];
item2 = list[1];
item3 = list[2];
}
public string FormatLine(string[] values, int[] columnWidths)
{
Code.NotNull(values, nameof(values));
Code.NotNull(columnWidths, nameof(columnWidths));
Code.AssertArgument(
values.Length <= columnWidths.Length,
nameof(columnWidths),
"columnWidth array to short");
return(values
.Select(EscapeValue).Zip(columnWidths, (s, w) => s.PadRight(w))
.Join(", "));
}
public static FieldInfo GetField <TEnum>(TEnum value) where TEnum : struct
{
Code.AssertArgument(value is Enum, nameof(value), "The value should Enum.");
var type = typeof(TEnum);
var name = Enum.GetName(type, value);
if (name == null)
{
return(null);
}
return(type.GetField(name, BindingFlags.Static | BindingFlags.Public));
}
public string Test03CodeAssertArgument()
{
var result = "";
var count = Count;
for (var i = 0; i < count; i++)
{
var arg = GetArg(i);
Code.AssertArgument(arg != null, nameof(arg), "Argument should be not null");
result = arg;
}
return(result);
}
public string Test04CodeAssertArgumentFormat()
{
var result = "";
var count = Count;
for (var i = 0; i < count; i++)
{
var arg = GetArg(i);
// ReSharper disable once PassStringInterpolation
Code.AssertArgument(arg != null, nameof(arg), "Argument {0} should be not null", nameof(arg));
result = arg;
}
return(result);
}
public string FormatLine(string[] values, int[] columnWidths)
{
Code.NotNull(values, nameof(values));
Code.NotNull(columnWidths, nameof(columnWidths));
Code.AssertArgument(
values.Length <= columnWidths.Length,
nameof(columnWidths),
"columnWidth array to short");
return
(EnumerableClass
// ReSharper disable once InvokeAsExtensionMethod
.Zip(
values.Select(EscapeValue),
columnWidths,
(s, w) => s.PadLeft(w))
.Join(", "));
}
public static byte[] TryGetChecksum(ResourceKey resourceKey, PdbChecksumAlgorithm checksumAlgorithm)
{
Code.AssertArgument(!resourceKey.IsEmpty, nameof(resourceKey), "The resource key should be non empty.");
var algName = GetChecksumName(checksumAlgorithm);
using (var stream = resourceKey.TryGetResourceStream())
{
if (stream == null)
{
return(Array <byte> .Empty);
}
using (var hashAlgorithm = HashAlgorithm.Create(algName))
{
// ReSharper disable once PossibleNullReferenceException
return(hashAlgorithm.ComputeHash(stream));
}
}
}
/// <summary>
/// Prints full data table
/// </summary>
/// <param name="writer">Instance of <see cref="TextWriter"/> to write to.</param>
/// <param name="data">Data to write.</param>
/// <param name="widths">Array of column widths</param>
/// <param name="indent">The indent.</param>
public static void Print(
[NotNull] TextWriter writer,
[NotNull, ItemNotNull] IEnumerable <string[]> data,
[NotNull] int[] widths,
[CanBeNull] string indent = null)
{
Code.NotNull(writer, nameof(writer));
Code.NotNull(data, nameof(writer));
Code.NotNull(widths, nameof(widths));
Code.AssertArgument(widths.Length > 0, nameof(widths), "At least one column must be specified");
Code.AssertArgument(widths.All(w => w > 0), nameof(widths), "Column width must be greater than 0");
var first = true;
foreach (var line in data)
{
Code.AssertState(line.Length <= widths.Length, $"{nameof(widths)} array to short.");
if (first)
{
first = false;
}
else
{
writer.WriteLine();
}
if (indent != null)
{
writer.Write(indent);
}
for (var i = 0; i < line.Length; i++)
{
var val = line[i];
var width = widths[i];
writer.Write(
val.Length > width
? val.Substring(0, width)
: val.PadRight(width));
}
}
}
private static bool TryFixBenchmarkXmlAnnotation(
AnnotateContext annotateContext, string xmlFileName,
CompetitionTarget competitionTarget,
CompetitionState competitionState)
{
Code.AssertArgument(
competitionTarget.CompetitionMetadata != null, nameof(competitionTarget),
"Competition metadata cannot be null for xml annotations.");
var xmlAnnotationDoc = annotateContext.TryGetXmlAnnotation(
xmlFileName,
competitionTarget.CompetitionMetadata.UseFullTypeName,
competitionState);
if (xmlAnnotationDoc == null)
{
return(false);
}
XmlAnnotations.AddOrUpdateXmlAnnotation(xmlAnnotationDoc, competitionTarget);
annotateContext.MarkAsChanged(xmlFileName);
return(true);
}
