using NUnit.Framework;
|
using System;
|
using System.Globalization;
|
using System.Linq;
|
using static OpenTap.UnitTests.FlagsAttributeTestStep;
|
|
namespace OpenTap.UnitTests
|
{
|
public class FlagsAttributeTestStep : TestStep
|
{
|
[Flags]
|
public enum NonPowers2Modes
|
{
|
None=0,
|
A = 1,
|
B = 2,
|
AB = A|B,
|
C = 4,
|
AC = A|C,
|
BC = B|C,
|
ABC = A|B|C,
|
D = 8,
|
AD = A|D,
|
BD = B|D,
|
ABD = A|B|D,
|
CD = C|D,
|
ACD = A|C|D,
|
BCD = B|C|D,
|
All = A|B|C|D
|
}
|
|
[Flags]
|
public enum Powers2Modes
|
{
|
None = 0,
|
[Display("A-Name")]
|
A = 1,
|
B = 2,
|
[Display("C-Name")]
|
C = 4,
|
D = 8
|
}
|
|
[Flags]
|
public enum LargeFlagValues : long
|
{
|
None = 0,
|
// shortA aliases with LongA in 32 bit systems
|
ShortA = 0x0000_00FF,
|
LongA = 0x0000_00FF_0000_0000L,
|
[Display("Long Long B")]
|
LongB = 1L << 60,
|
}
|
|
#region Settings
|
|
public NonPowers2Modes MyNonPowers2Mode { get; set; }
|
public Powers2Modes MyPowers2Mode { get; set; }
|
public LargeFlagValues MyLargeFlagValues { get; set; }
|
|
#endregion
|
public override void Run() { }
|
}
|
|
[TestFixture]
|
public class FlagsEnumTest
|
{
|
[Test]
|
public void NonPowers2EnumTest()
|
{
|
var flagStep = new FlagsAttributeTestStep();
|
var stepAnnotation = AnnotationCollection.Annotate(flagStep);
|
var mem = stepAnnotation.GetMember(nameof(FlagsAttributeTestStep.MyNonPowers2Mode));
|
var select = mem.Get<IMultiSelect>();
|
|
Assert.True(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.None));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyNonPowers2Mode = NonPowers2Modes.AC;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.A | NonPowers2Modes.C | NonPowers2Modes.AC));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 3);
|
|
flagStep.MyNonPowers2Mode = NonPowers2Modes.BC;
|
stepAnnotation.Read();
|
Assert.False(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.A)); // A should be unselected
|
Assert.True(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.B | NonPowers2Modes.C | NonPowers2Modes.BC));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 3);
|
|
flagStep.MyNonPowers2Mode |= NonPowers2Modes.D;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.D | NonPowers2Modes.B | NonPowers2Modes.C | NonPowers2Modes.BC));
|
Assert.True(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.BD | NonPowers2Modes.CD | NonPowers2Modes.BCD));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 7);
|
|
// Unselection
|
flagStep.MyNonPowers2Mode ^= NonPowers2Modes.B; // Remove B from previous selection
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.D | NonPowers2Modes.C | NonPowers2Modes.CD));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 3);
|
|
//Select All
|
flagStep.MyNonPowers2Mode = NonPowers2Modes.All;
|
stepAnnotation.Read();
|
Assert.False(select.Selected.Cast<Enum>().Contains(NonPowers2Modes.None));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 15);
|
}
|
|
[Test]
|
public void Powers2EnumTest()
|
{
|
var flagStep = new FlagsAttributeTestStep();
|
var stepAnnotation = AnnotationCollection.Annotate(flagStep);
|
var mem = stepAnnotation.GetMember(nameof(FlagsAttributeTestStep.MyPowers2Mode));
|
var select = mem.Get<IMultiSelect>();
|
|
Assert.True(select.Selected.Cast<Enum>().Contains(Powers2Modes.None));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyPowers2Mode = Powers2Modes.C;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(Powers2Modes.C));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyPowers2Mode |= Powers2Modes.D;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(Powers2Modes.C));
|
Assert.True(select.Selected.Cast<Enum>().Contains(Powers2Modes.D));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 2);
|
Assert.False(select.Selected.Cast<Enum>().Contains(Powers2Modes.C | Powers2Modes.D)); // C|D is not a defined enum constant
|
|
flagStep.MyPowers2Mode = Powers2Modes.A;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(Powers2Modes.A));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
}
|
|
[Test]
|
public void LargeFlagValuesTest()
|
{
|
var flagStep = new FlagsAttributeTestStep();
|
var stepAnnotation = AnnotationCollection.Annotate(flagStep);
|
var mem = stepAnnotation.GetMember(nameof(FlagsAttributeTestStep.MyLargeFlagValues));
|
var select = mem.Get<IMultiSelect>();
|
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.None));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyLargeFlagValues = LargeFlagValues.ShortA;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.ShortA));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyLargeFlagValues = LargeFlagValues.LongA;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.LongA));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyLargeFlagValues = LargeFlagValues.LongB;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.LongB));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 1);
|
|
flagStep.MyLargeFlagValues |= LargeFlagValues.LongA;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.LongB) &&
|
select.Selected.Cast<Enum>().Contains(LargeFlagValues.LongA));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 2);
|
|
flagStep.MyLargeFlagValues = LargeFlagValues.ShortA | LargeFlagValues.LongA;
|
stepAnnotation.Read();
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.ShortA));
|
Assert.True(select.Selected.Cast<Enum>().Contains(LargeFlagValues.LongA));
|
Assert.AreEqual(select.Selected.Cast<Enum>().Count(), 2);
|
|
}
|
|
[Test]
|
public void EnumReadableStringTest()
|
{
|
void testConversions(string a, Enum b)
|
{
|
Assert.AreEqual(a, Utils.EnumToReadableString(b));
|
var c = (Enum)StringConvertProvider.FromString(a, TypeData.FromType(b.GetType()), null, CultureInfo.InvariantCulture);
|
Assert.AreEqual(c, b);
|
}
|
|
testConversions("None", (Powers2Modes)0);
|
|
testConversions("A-Name", Powers2Modes.A);
|
testConversions("A-Name", (Powers2Modes)1);
|
|
testConversions("B", Powers2Modes.B);
|
testConversions("B", (Powers2Modes)2);
|
|
testConversions("A-Name | B", Powers2Modes.A | Powers2Modes.B);
|
testConversions("A-Name | B", (Powers2Modes)3);
|
|
testConversions("A-Name | B | C-Name", Powers2Modes.A | Powers2Modes.B | Powers2Modes.C);
|
testConversions("A-Name | B | C-Name", (Powers2Modes)7);
|
|
testConversions("None", (LargeFlagValues)0);
|
|
testConversions("ShortA", LargeFlagValues.ShortA);
|
testConversions("LongA", LargeFlagValues.LongA);
|
testConversions("Long Long B", LargeFlagValues.LongB);
|
testConversions("LongA | Long Long B", LargeFlagValues.LongA | LargeFlagValues.LongB);
|
|
Assert.AreEqual("16", Utils.EnumToReadableString((Powers2Modes)16));
|
Assert.AreEqual("32", Utils.EnumToReadableString((Powers2Modes)32));
|
Assert.AreEqual("16", Utils.EnumToReadableString((LargeFlagValues)16));
|
}
|
}
|
}
|
