/// <summary>
/// 返回支付的返回代码
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string GetReturnCode(Int32 str)
{
EnumCode typef = new EnumCode();
typef = (EnumCode)Enum.ToObject(typeof(EnumCode), str);
return(Enum.GetName(typeof(EnumCode), str));
}
public void TestDefined()
{
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => EnumCode.Defined(FileAccess.Write + 123, "arg00"));
Assert.That(ex.Message, Does.Contain("arg00"));
Assert.That(ex.Message, Does.Contain("Unexpected value"));
Assert.DoesNotThrow(() => EnumCode.Defined(FileAccess.Write, "arg00"));
}
public void TestFlagUnset()
{
var ex = Assert.Throws <ArgumentException>(() => EnumCode.AnyFlagUnset(FileAccess.ReadWrite, "arg00", FileAccess.Write));
Assert.That(ex.Message, Does.Contain("arg00"));
Assert.That(ex.Message, Does.Contain("The value of the arg00 argument "));
Assert.That(ex.Message, Does.Contain(" should not include flag "));
Assert.DoesNotThrow(() => EnumCode.AnyFlagUnset(FileAccess.Read, "arg00", FileAccess.Write));
}
/// <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 void TestDebugDefined()
{
#if DEBUG
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => EnumCode.Defined(FileAccess.Write + 123, "arg00"));
Assert.That(ex.Message, Does.Contain("arg00"));
Assert.That(ex.Message, Does.Contain("Unexpected value"));
#else
// ReSharper disable once InvocationIsSkipped
Assert.DoesNotThrow(() => DebugEnumCode.Defined(FileAccess.Write + 123, "arg00"));
#endif
// ReSharper disable once InvocationIsSkipped
Assert.DoesNotThrow(() => DebugEnumCode.Defined(FileAccess.Write, "arg00"));
}
public void TestEnumUseCase()
{
var permissions = PermittedActions.None;
var readOrOwner = PermittedActions.Read | PermittedActions.SetOwner;
Assert.AreEqual(permissions, PermittedActions.None);
permissions = permissions.SetFlag(PermittedActions.Read);
Assert.AreEqual(permissions, PermittedActions.Read);
permissions = permissions.SetFlag(PermittedActions.Write);
Assert.AreEqual(permissions, PermittedActions.ReadWrite);
permissions = permissions.ClearFlag(PermittedActions.Write);
Assert.AreEqual(permissions, PermittedActions.Read);
// conditional set or clear
permissions = permissions.SetFlag(PermittedActions.ReadContent, enabled: false);
Assert.AreEqual(permissions, PermittedActions.ReadMetadata);
permissions = permissions.SetFlag(PermittedActions.ReadWrite, enabled: true);
Assert.AreEqual(permissions, PermittedActions.ReadWrite);
// Checks that entire bit combination is set
Assert.IsFalse(permissions.IsFlagSet(readOrOwner));
Assert.IsTrue(permissions.IsFlagSet(PermittedActions.Read));
Assert.IsFalse(permissions.IsFlagSet(PermittedActions.SetOwner));
// Checks that any bit is NOT set
Assert.IsTrue(permissions.IsAnyFlagUnset(readOrOwner));
Assert.IsFalse(permissions.IsAnyFlagUnset(PermittedActions.Read));
Assert.IsTrue(permissions.IsAnyFlagUnset(PermittedActions.SetOwner));
// Checks that any bit is set
Assert.IsTrue(permissions.IsAnyFlagSet(readOrOwner));
Assert.IsTrue(permissions.IsAnyFlagSet(PermittedActions.Read));
Assert.IsFalse(permissions.IsAnyFlagSet(PermittedActions.SetOwner));
// Checks that entire bit combination is NOT set
Assert.IsFalse(permissions.IsFlagUnset(readOrOwner));
Assert.IsFalse(permissions.IsFlagUnset(PermittedActions.Read));
Assert.IsTrue(permissions.IsFlagUnset(PermittedActions.SetOwner));
// Assertions
Assert.DoesNotThrow(() => EnumCode.FlagSet(permissions, nameof(permissions), PermittedActions.Read));
Assert.DoesNotThrow(() => EnumCode.AnyFlagUnset(permissions, nameof(permissions), readOrOwner));
Assert.DoesNotThrow(() => EnumCode.AnyFlagSet(permissions, nameof(permissions), PermittedActions.Read));
Assert.DoesNotThrow(() => EnumCode.FlagUnset(permissions, nameof(permissions), PermittedActions.SetOwner));
}
public void TestFlagsDefined()
{
var allDefinedFlags = EnumHelper.GetFlagsMask <BindingFlags>();
// ReSharper disable once RedundantCast
var allFlags = (BindingFlags)(int)-1;
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => EnumCode.FlagsDefined(allFlags, "arg00"));
Assert.That(ex.Message, Does.Contain("arg00"));
Assert.That(ex.Message, Does.Contain("Unexpected value"));
Assert.Throws <ArgumentOutOfRangeException>(
() => EnumCode.Defined(allDefinedFlags, "arg00"));
Assert.DoesNotThrow(
() => EnumCode.FlagsDefined(allDefinedFlags, "arg00"));
}
public void TestAnyFlagSet()
{
// Arg assertion
Exception ex = Assert.Throws <ArgumentException>(
() => EnumCode.AnyFlagSet(FileAccess.Read, "arg00", FileAccess.Write));
Assert.That(ex.Message, Does.Contain("arg00"));
Assert.That(ex.Message, Does.Contain("The value of the arg00 argument "));
Assert.That(ex.Message, Does.Contain(" should include any flag from "));
Assert.DoesNotThrow(() => EnumCode.AnyFlagSet(FileAccess.Read, "arg00", FileAccess.ReadWrite));
// State assertion
ex = Assert.Throws <InvalidOperationException>(
() => EnumCode.AnyStateFlagSet(FileAccess.Read, FileAccess.Write, "someUniqueMessage"));
Assert.AreEqual(ex.Message, "someUniqueMessage");
ex = Assert.Throws <InvalidOperationException>(
() => EnumCode.AnyStateFlagSet(FileAccess.Read, FileAccess.Write, "someUniqueMessage {0}", "someUniqueFormatArg"));
Assert.AreEqual(ex.Message, "someUniqueMessage someUniqueFormatArg");
Assert.DoesNotThrow(() => EnumCode.AnyStateFlagSet(FileAccess.Read, FileAccess.ReadWrite, "someUniqueMessage"));
}
/// <summary>Initializes a new instance of the <see cref="FileIoMetricProvider"/> class.</summary>
/// <param name="metricSource">The IO metric source.</param>
/// <param name="resultIsRelative">if set to <c>true</c> [result is relative].</param>
public FileIoMetricProvider(IoMetricSource metricSource, bool resultIsRelative)
: base(SingleValueMetricCalculator.Instance, resultIsRelative)
{
EnumCode.Defined(metricSource, nameof(metricSource));
MetricSource = metricSource;
}
public static string GetSymbol(EnumCode symbolNumb)
{
ConfigCodeEnum symbol = CreateEnum(symbolNumb);
return(symbol.GetSymbol());
}
public static EnumCode CreateCode(EnumCode symbolNumb)
{
return((EnumCode)symbolNumb.ToEnum <ConfigCodeEnum>(GetDefaultsEnum()));
}
public static ConfigCodeEnum CreateEnum(EnumCode symbolNumb)
{
return(symbolNumb.ToEnum <ConfigCodeEnum>(GetDefaultsEnum()));
}
