public void EnumTests()
{
JValue v = new JValue(StringComparison.Ordinal);
Assert.AreEqual(JTokenType.Integer, v.Type);
string s = v.ToString();
Assert.AreEqual("Ordinal", s);
StringComparison e = v.ToObject <StringComparison>();
Assert.AreEqual(StringComparison.Ordinal, e);
dynamic d = new JValue(StringComparison.CurrentCultureIgnoreCase);
StringComparison e2 = (StringComparison)d;
Assert.AreEqual(StringComparison.CurrentCultureIgnoreCase, e2);
string s1 = d.ToString();
Assert.AreEqual("CurrentCultureIgnoreCase", s1);
string s2 = (string)d;
Assert.AreEqual("CurrentCultureIgnoreCase", s2);
d = new JValue("OrdinalIgnoreCase");
StringComparison e3 = (StringComparison)d;
Assert.AreEqual(StringComparison.OrdinalIgnoreCase, e3);
v = new JValue("ORDINAL");
d = v;
StringComparison e4 = (StringComparison)d;
Assert.AreEqual(StringComparison.Ordinal, e4);
StringComparison e5 = v.ToObject <StringComparison>();
Assert.AreEqual(StringComparison.Ordinal, e5);
v = new JValue((int)StringComparison.OrdinalIgnoreCase);
Assert.AreEqual(JTokenType.Integer, v.Type);
StringComparison e6 = v.ToObject <StringComparison>();
Assert.AreEqual(StringComparison.OrdinalIgnoreCase, e6);
// does not support EnumMember. breaking change to add
ExceptionAssert.Throws <ArgumentException>(
() =>
{
d = new JValue("value_a");
EnumA e7 = (EnumA)d;
Assert.AreEqual(EnumA.ValueA, e7);
},
"Requested value 'value_a' was not found."
);
}
static void Main(string[] args)
{
EnumA a = ((EnumA[])Enum.GetValues(typeof(EnumA)))[0];
Console.WriteLine(a);
EnumB boa = (EnumB)3;
Console.WriteLine(boa);
}
public string Repro(EnumA a, EnumB b)
=> (a, b) switch
{
(EnumA.A, EnumB.X) => "AX",
(_, EnumB.Y) => "_Y",
(EnumA.B, EnumB.X) => "BX",
(_, EnumB.Z) => "_Z",
(_, _) => throw new ArgumentException()
};
}
public void Map_EnumToNullable_Success(EnumA? sourceValue, int? expectedValue)
{
TinyMapper.Bind<Source3, Target3>();
var source = new Source3
{
Value = sourceValue
};
var result = TinyMapper.Map<Target3>(source);
Assert.Equal(expectedValue, result.Value);
}
public void Map_NullableToEnum_Success(int? sourceValue, EnumA? expectedValue)
{
TinyMapper.Bind<Source4, Target4>();
var source = new Source4
{
Value = sourceValue
};
var result = TinyMapper.Map<Target4>(source);
Assert.Equal(expectedValue, result.Value);
}
public static void showEnum()
{
EnumA a = EnumA.A;
EnumB b = EnumB.B;
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(a.GetType());
Console.WriteLine(b.GetType());
// Console.WriteLine(a == b); // Can't comparable
}
public EnumA DoSomething(EnumA m)
{
return(m);
}
public EnumA EchoEnum(EnumA arg)
{
return(arg);
}
public void TestNonLocalisableEnumReturnsDescriptionOrToString(EnumA value, string expected)
{
Assert.That(value.GetLocalisableDescription().ToString(), Is.EqualTo(expected));
}
private static void Ololo(EnumA ºa)
{
}
public EnumA DoSomething(EnumA m)
{
return m;
}
public void EnumMethod(EnumA val)
{
AmbigousMethodsTests.Output = "MethodEnumA";
}
public EnumB Convert_of_EnumA_to_EnumB_By_Inference_Types(EnumA enumA, EnumB enumB)
{
return(EnumLibrary.Convert(enumA, enumB));
}
private static void Ololo(EnumA a)
{
Contract.Requires(Enum.IsDefined(typeof(EnumA), a));
}
public EnumB Convert_of_EnumA_to_EnumB(EnumA enumA)
{
return(EnumLibrary.Convert <EnumA, EnumB>(enumA));
}
public EnumA EchoEnum(EnumA arg) {
return arg;
}
void CallEnumSeqEcho()
{
EnumA[] arg = new EnumA[1000];
m_testService.EnumIdlSeqEcho(arg);
}
void CallEnumEcho()
{
EnumA arg = EnumA.EnumA_C;
m_testService.EchoEnum(arg);
}
void CallEnumSeqEcho() {
EnumA[] arg = new EnumA[1000];
m_testService.EnumIdlSeqEcho(arg);
}