public void LongSize(LongEnum @enum)
{
Value value = Value.Create(@enum);
Assert.True(value.TryGetValue(out LongEnum result));
Assert.Equal(@enum, result);
Assert.True(value.TryGetValue(out LongEnum? nullResult));
Assert.Equal(@enum, nullResult !.Value);
value = Value.Create((LongEnum?)@enum);
Assert.True(value.TryGetValue(out result));
Assert.Equal(@enum, result);
Assert.True(value.TryGetValue(out nullResult));
Assert.Equal(@enum, nullResult !.Value);
// Create boxed
value = new(@enum);
Assert.True(value.TryGetValue(out result));
Assert.Equal(@enum, result);
Assert.True(value.TryGetValue(out nullResult));
Assert.Equal(@enum, nullResult !.Value);
value = new((LongEnum?)@enum);
Assert.True(value.TryGetValue(out result));
Assert.Equal(@enum, result);
Assert.True(value.TryGetValue(out nullResult));
Assert.Equal(@enum, nullResult !.Value);
}
public void LongSize(LongEnum testValue)
{
Value value = Value.Create(testValue);
Assert.True(value.TryGetValue(out LongEnum result));
Assert.AreEqual(testValue, result);
Assert.True(value.TryGetValue(out LongEnum? nullResult));
Assert.AreEqual(testValue, nullResult !.Value);
value = Value.Create((LongEnum?)testValue);
Assert.True(value.TryGetValue(out result));
Assert.AreEqual(testValue, result);
Assert.True(value.TryGetValue(out nullResult));
Assert.AreEqual(testValue, nullResult !.Value);
// Create boxed
value = new(testValue);
Assert.True(value.TryGetValue(out result));
Assert.AreEqual(testValue, result);
Assert.True(value.TryGetValue(out nullResult));
Assert.AreEqual(testValue, nullResult !.Value);
value = new((LongEnum?)testValue);
Assert.True(value.TryGetValue(out result));
Assert.AreEqual(testValue, result);
Assert.True(value.TryGetValue(out nullResult));
Assert.AreEqual(testValue, nullResult !.Value);
}
static void TestGetHashCode()
{
Console.WriteLine("# TestGetHashCode");
Enum a = new LongEnum();
Console.WriteLine(a.GetHashCode());
}
public static int test_0_delegate_invoke_wrappers_gsharedvt()
{
var enums = new LongEnum [] { LongEnum.A };
SetArrayValue_(enums);
return(0);
}
public void WriteLongEnum(LongEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var enumResult = MsgPackSerializer.Serialize(enumValue, intEnumContext);
var valueResult = MsgPackSerializer.Serialize((long)enumValue, intEnumContext);
enumResult.ShouldBe(valueResult);
}
static void TestToString()
{
Console.WriteLine("# TestToString");
LongEnum v = LongEnum.Name;
Console.WriteLine(v);
Console.WriteLine(ULongEnum.Test);
}
static void TestCast()
{
Console.WriteLine("# TestCast");
LongEnum v = LongEnum.Name;
long l = (long)v;
Console.WriteLine(l);
}
public void ReadLongEnum(LongEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var bytes = MsgPackSerializer.Serialize((long)enumValue, intEnumContext);
var enumResult = MsgPackSerializer.Deserialize <LongEnum>(bytes, intEnumContext);
enumResult.ShouldBe(enumValue);
}
public void EnumLongTest()
{
LongEnum longEnum = LongEnum.LongElementOne;
Assert.AreEqual(1, NuGenEnum.FlagsSetOn(longEnum));
longEnum |= LongEnum.LongElementThree;
Assert.AreEqual(2, NuGenEnum.FlagsSetOn(longEnum));
}
public void it_will_read_enum_using_alternate_underlying_type()
{
const LongEnum expected = LongEnum.B;
using (var reader = new BinaryReader(new MemoryStream(BitConverter.GetBytes((long)expected))))
{
var value = reader.ReadStruct <LongEnum>();
value.Should().BeOfType <LongEnum>().And.Be(expected);
reader.BaseStream.ShouldBeEof();
}
}
public void SetFlagTest_LongEnum()
{
LongEnum flags = default;
// Set each flag and clear
for (int i = 0; i < sizeof(LongEnum) * 8; i++)
{
LongEnum newFlag = (LongEnum)(1 << i);
flags.SetFlags(newFlag);
flags.Should().Be(newFlag);
flags.ClearFlags(newFlag);
flags.Should().Be(0);
}
}
static string Test(LongEnum v)
{
string s;
switch (v)
{
case LongEnum.Option0: s = "Option0"; break;
case LongEnum.Option1: s = "Option1"; break;
case LongEnum.Option2: s = "Option2"; break;
default: throw new Exception();
}
return(s);
}
void Test()
{
MyEnum a = MyEnum.A;
MyEnum b = MyEnum.B;
int c;
LongEnum d = LongEnum.C;
c = (int)a;
a = b;
b = (MyEnum)c;
c = (int)d;
FlagEnum E = FlagEnum.A;
FlagEnum F = FlagEnum.B;
E = E | F;
}
public string UnoundFuncWithEnumParameter(LongEnum p1, FlagsEnum p2)
{
return("UnboundFuncWithEnumParameters(" + p1 + "," + p2 + ")");
}
public string UnoundFuncWithEnumParameter(LongEnum p1, FlagsEnum p2)
{
return "UnboundFuncWithEnumParameters(" + p1 + "," + p2 + ")";
}
public static string Int2LongString(int month)
{
LongEnum enumMonth = (LongEnum)month;
return(enumMonth.ToString());
}
public void ON_EvaluateContainsFlags_WHEN_Underlying_Enum_Type_Long_SHOULD_Return(FlagCheckResult expected, LongEnum source, LongEnum flags)
{
var actual = UUT.EvaluateContainsFlags(source, flags);
Assert.AreEqual(expected, actual);
}
public void SetPrivateLongEnumProperty(LongEnum value)
{
private_long_enum_property = value;
}
public void SetPrivateLongEnumField(LongEnum value)
{
private_long_enum_field = value;
}
public void DataRowEnum_Long(LongEnum testEnum)
{
Assert.IsTrue(true);
}
public Primitives(sbyte sb, byte b, short s, ushort us, int i, uint ui, long l, ulong ul,
SByteEnum sbe, ByteEnum be, ShortEnum se, UShortEnum use, IntEnum ie, UIntEnum uie, LongEnum le, ULongEnum ule,
char c, bool bo, float f, double d,
string str, Type t, int[] arr, object obj)
{
SByteConstructor = sb;
ByteConstructor = b;
ShortConstructor = s;
UShortConstructor = us;
IntConstructor = i;
UIntConstructor = ui;
LongConstructor = l;
ULongConstructor = ul;
SByteEnumConstructor = sbe;
ByteEnumConstructor = be;
ShortEnumConstructor = se;
UShortEnumConstructor = use;
IntEnumConstructor = ie;
UIntEnumConstructor = uie;
LongEnumConstructor = le;
ULongEnumConstructor = ule;
CharConstructor = c;
BoolConstructor = bo;
FloatConstructor = f;
DoubleConstructor = d;
StringConstructor = str;
TypeConstructor = t;
ArrayConstructor = arr;
ObjectConstructor = obj;
}
