public TooManyLabelsInSwitch(int n, MyEnum en)
{
switch (n)
{
case 0:
break;
default:
break;
}
switch (n) // Noncompliant {{Consider reworking this "switch" to reduce the number of "case"s from 3 to at most 2.}}
// ^^^^^^
{
case 0:
case 1:
break;
default:
break;
}
switch (en)
{
case MyEnum.A:
break;
case MyEnum.B:
break;
case MyEnum.C:
break;
case MyEnum.D:
break;
default:
break;
}
}
public TooManyLabelsInSwitch(int n, MyEnum en)
{
switch (n)
{
case 0:
break;
default:
break;
}
switch (n) // Noncompliant
{
case 0:
case 1:
break;
default:
break;
}
switch (en)
{
case MyEnum.A:
break;
case MyEnum.B:
break;
case MyEnum.C:
break;
case MyEnum.D:
break;
default:
break;
}
}
public static void Main (string[] args) {
Console.WriteLine(Field);
Field = (MyEnum)f(0);
Console.WriteLine(Field);
Field = (MyEnum)f(1);
Console.WriteLine(Field);
Field = MyEnum.C;
Console.WriteLine(Field);
}
public MySerializableClass(int a, string b, byte c, MyEnum d, float e)
{
this.a = a;
this.b = b;
this.c = c;
this.d = d;
this.e = e;
this.dt = this.dt = new DateTime(2007, 1, 22);
}
public void RoundTrip(MyEnum e)
{
var javaName = EnumBuilder<MyEnum>.GetJavaName(e);
foreach (var c in javaName)
{
Assert.True(char.IsUpper(c) || c == '_' || char.IsNumber(c));
}
var roundTripped = EnumBuilder<MyEnum>.Parse(javaName);
Assert.Equal(e, roundTripped);
}
public void When_enums_have_unequal_names_it_should_throw()
{
// Arrange
MyEnum subject = MyEnum.One;
MyEnumOtherValue expected = MyEnumOtherValue.One;
// Act
Action act = () => subject.Should().NotHaveSameNameAs(expected, "we want to test the failure {0}", "message");
// Assert
act.Should().Throw <XunitException>()
.WithMessage("*because we want to test the failure message*");
}
public static void Main(string[] args)
{
Console.InputEncoding = System.Text.Encoding.Unicode;
Console.OutputEncoding = System.Text.Encoding.Unicode;
Console.WriteLine((int)MyEnum.LOLOp);
MyEnum en = MyEnum.FirstOp;
MyEnum m = SomeMethod();
System.Console.WriteLine("LOL operation");
NamedParam(2, 4, s: 54);
Console.WriteLine(f(3));
}
public static string GetName(MyTrashRemovalFlags flag)
{
MyStringId id;
if (m_names.TryGetValue(flag, out id))
{
return(MyTexts.GetString(id));
}
else
{
return(MyEnum <MyTrashRemovalFlags> .GetName(flag));
}
}
public bool TryDoSomethingBaz(MyEnum whatever, int input)
{
switch (whatever)
{
case MyEnum.lol:
_baz = _lawl + input;
return(true);
case MyEnum.wtf:
_baz = _wtf * input;
return(false);
}
}
public void ShouldTryConvertEnumImplicitlyWithNonGenericMethod()
{
// Arrange
object sourceObject = MyEnum.TestValue;
const MyEnum DefaultValue = default(MyEnum);
IConverterRegistry converterRegistry = new ConverterRegistry();
// Act
object convertedObject = converterRegistry.TryConvert(typeof(object), typeof(MyEnum), sourceObject, DefaultValue);
// Assert
convertedObject.Should().Be(sourceObject);
}
static void TestConstrainedMethodCalls()
{
using (MyStruct s = new MyStruct())
{
((Object)s).ToString();
}
// Enum.GetHashCode optimization requires special treatment
// in native signature encoding
MyEnum e = MyEnum.Apple;
e.GetHashCode();
}
static int Main ()
{
int v = Test (Foo.A);
if (v != 0)
return v;
MyEnum [] arr = new MyEnum [2];
arr [0] = MyEnum.c;
if (arr [0] != MyEnum.c)
return 3;
return 0;
}
public static void GivenAnEnumParameter_ParsingShouldWork(string argument, MyEnum expectedM)
{
var args = new[] { "-m", argument };
MyEnum?parsedM = default;
var builder = FluentArgsBuilder.New()
.Parameter <MyEnum>("-m").IsRequired()
.Call(m => parsedM = m);
var parseSuccess = builder.Parse(args);
parseSuccess.Should().BeTrue();
parsedM.Should().Be(expectedM);
}
public void When_enums_are_equal_it_should_throw()
{
// Arrange
MyEnum subject = MyEnum.One;
MyEnum expected = MyEnum.One;
// Act
Action act = () => subject.Should().NotBe(expected, "we want to test the failure {0}", "message");
// Assert
act.Should().Throw <XunitException>()
.WithMessage("*because we want to test the failure message*");
}
public void Colors(MyEnum myEnum)
{
switch (myEnum)
{
case MyEnum.Red:
Console.WriteLine("Red");
break;
case MyEnum.Yellow:
Console.WriteLine("Yellow");
break;
}
}
public Test(object o0, dynamic o1, dynamic o2, MyClass o3, MyStruct o4, MyEnum o5, int o6, string o7, object o8, sbyte o9)
{
d0 = o0;
d1 = o1;
d2 = o2;
d3 = o3;
d4 = o4;
d5 = o5;
d6 = o6;
d7 = o7;
d8 = o8;
d9 = o9;
}
static void Main(string[] args)
{
MyEnum e1 = MyEnum.male;
MyEnum e2 = e1;
MyEnum e3 = MyEnum.female;
Console.WriteLine("e1: " + e1);
Console.WriteLine("e2: " + e2);
Console.WriteLine("e3: " + e3);
A a = new A();
a.a = 3;
}
static void Main(string[] args)
{
Student s1 = new Student();
Student s2 = new Student(16, "Nguyen Van Anh");
s2.AddMark("Math", 8.6, 2);
s2.AddMark("Physics", 6.6, 1);
double avarage = s2.CalculateAvarage();
MyEnum pos = s2.PositionInClass();
Console.ReadLine();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
MyEnum myEnum = new MyEnum();
myEnum.Set();
NullCond nc = new NullCond();
Person p = null;
nc.TakePerson(p);
Student s = new Student("Ivanov");
s.SetAge(20);
Student s1 = new Student("Petrov");
s1.SetAge(20);
Console.WriteLine(Student.UNIVERSITY);
Console.WriteLine(Student.counter);
Console.WriteLine("\nPROPERTIES: ");
Calculation calc = new Calculation();
calc.SetX(10);
Console.WriteLine(calc.GetX());
calc.SetY = 12;
// Console.WriteLine(calc.SetY);
Console.WriteLine(calc.GetY);
calc.Y = 12;
int a = calc.Y;
calc.Name = "Point 1";
// calc.Operation = '-'; set private
Console.WriteLine(calc.Operation);
// Console.WriteLine(calc.Name);
Console.WriteLine(Settings.Factorial(5));
if (Settings.Key != null)
{
}
}
static void Main(string[] args)
{
Console.WriteLine(new string('_', 50));
DateTime data = new DateTime(2020, 2, 13);
DateTime today = DateTime.Now;
TimeSpan left = data - today;
Console.WriteLine("до мой днем раждения осталось {0} день", left.Days);
Console.WriteLine("до мой днем раждения осталось {0} час", left.TotalHours);
Console.WriteLine(new string('_', 50));
MyEnum my = MyEnum.one;
Console.WriteLine("{0}-{1}", my, (int)my);
Console.WriteLine(new string('_', 10));
Type typemy = my.GetType(); //1
Console.WriteLine(typemy);
Type typemy1 = Enum.GetUnderlyingType(typemy); //2 //...enumi tareri typ@
Console.WriteLine(typemy1);
Console.WriteLine(Enum.GetUnderlyingType(typeof(MyEnum))); //3=2
Console.WriteLine(typeof(MyEnum)); //4=1
Console.WriteLine(my.ToString());
Console.WriteLine(Enum.Format(typeof(MyEnum), MyEnum.one, "X"));
Console.WriteLine(Enum.Format(typeof(MyEnum), MyEnum.one, "D"));
Console.WriteLine(Enum.Format(typeof(MyEnum), 2, "G"));
Console.WriteLine(new string('_', 10));
for (MyEnum number = MyEnum.zero; number <= MyEnum.tree; number++)
{
Console.WriteLine("{0}-{1}", number, (int)number);
}
Console.WriteLine(new string('_', 50));
Array array = Enum.GetValues(typeof(MyEnum)); /// enum-i tarer@ qcum enq zangvaci mej
Console.WriteLine("Array Lenght equal -{0}", array.Length);
for (int i = 0; i < array.Length; i++)
{
Console.WriteLine("name const {0} a value {0:D}", array.GetValue(i));
}
Console.ReadKey();
}
public string FromEnum(MyEnum myEnum)
{
switch (myEnum)
{
case MyEnum.NONE: return("1");
case MyEnum.A: return("2");
case MyEnum.B: return("3");
default: throw new ArgumentOutOfRangeException();
}
// later we can add unwanted code in this method
}
public void EnumTest()
{
var expected = 1;
var v = (int)My.GetEnum <MyEnum>("Yes");
Assert.IsTrue(v == 1, $"Invalid enum {v} should be {expected}");
v = (int)My.GetEnum <MyEnum>("xxx");
Assert.IsTrue(v == 0, $"Invalid enum {v} should be {expected}");
MyEnum name = My.GetEnumByIndex <MyEnum>(1);
Assert.IsTrue(name.ToString() == "Yes", $"Invalid enum {name} should be Yes.");
}
public void Helper(MyEnum e)
{
if (!isDisposed)
{
if (e == MyEnum.User)
{
//dispose managed resources
Console.WriteLine("dispose managed resources");
}
//dispose unmanaged resources
Console.WriteLine("dispose unmanaged resources");
isDisposed = true;
}
}
private void btnNext_Click(object sender, RoutedEventArgs e)
{
getenum = getenum + 1;
string[] data = getenum.ToString().Split('_');
frameContainer.Navigate(new Uri(data[0] + "/" + data[1] + ".xaml", UriKind.RelativeOrAbsolute));
if (getenum == MyEnum.Configs_Settings)
{
btnNext.IsEnabled = false;
}
if (getenum == MyEnum.Commercial_ContactRole)
{
btnPrev.IsEnabled = true;
}
}
public static void Main()
{
MyEnum e = MyEnum.NONE;
if (e == MyEnum.NONE)
{
Console.WriteLine("Uquality working");
}
e = (MyEnum)1;
Console.WriteLine("case 1 -> should print \"ONE\": ");
Console.WriteLine(e);
int result = (int)e;
Console.WriteLine("case 2 -> should print \"1\": ");
Console.WriteLine(result);
MyIncompleteEnum ie = MyIncompleteEnum.SEVEN;
if (ie == MyIncompleteEnum.SEVEN)
{
Console.WriteLine("Uquality working");
}
ie = (MyIncompleteEnum)7;
Console.WriteLine("case 3 -> should print \"SEVEN\": ");
Console.WriteLine(ie);
int result2 = (int)ie;
Console.WriteLine("case 4 -> should print \"7\": ");
Console.WriteLine(result2);
MyDisorderedEnum de = MyDisorderedEnum.ONE;
if (de == MyDisorderedEnum.ONE)
{
Console.WriteLine("Uquality working");
}
de = (MyDisorderedEnum)1;
Console.WriteLine("case 5 -> should print \"ONE\": ");
Console.WriteLine(de);
int result3 = (int)de;
Console.WriteLine("case 6 -> should print \"1\": ");
Console.WriteLine(result3);
}
public static int Num(this MyEnum val)
{
int n = 0;
FieldInfo fi = val.GetType().GetField(val.ToString());
TestAttribute[] attrs =
fi.GetCustomAttributes(typeof(TestAttribute),
false) as TestAttribute[];
if (attrs.Length > 0)
{
n = attrs[0].Num;
}
return(n);
}
//-------------------------------------------------------------------------
// デバッグ
public void OnDebug()
{
using (new GUILayout.VerticalScope(GUI.skin.box)) {
GUILayout.Label($"連鎖数:{ChainCount}");
using (new GUILayout.HorizontalScope()) {
MyEnum.ForEach <Define.App.Attribute>((attribute) => {
GUILayout.Label($"{attribute}:{this.vanishCounts[(int)attribute]}");
});
}
GUILayout.Label($"総数:{TotalVanishCount}");
}
}
public void IsImmutable_Enum_MyEnum()
{
//Arrange
var validator = new ImmutableValidator();
MyEnum target = MyEnum.A;
//Act
#pragma warning disable CS0618 // Type or member is obsolete
var actual = validator.IsImmutable(target);
#pragma warning restore CS0618 // Type or member is obsolete
//Assert
Assert.True(actual);
}
private void Issue1881()
{
#pragma warning disable CS0219
MyEnum enumLocal1 = MyEnum.VALUE1;
MyEnum enumLocal2 = (MyEnum)0;
enumLocal2 = MyEnum.VALUE1;
object enumLocal3 = MyEnum.VALUE2;
object enumLocal4 = new object();
enumLocal4 = MyEnum.VALUE2;
ValueType enumLocal5 = MyEnum.VALUE1;
ValueType enumLocal6 = (MyEnum)0;
enumLocal6 = MyEnum.VALUE2;
#pragma warning restore CS0219
}
private void Issue1881()
{
MyEnum enumLocal1 = MyEnum.VALUE1;
MyEnum enumLocal2 = (MyEnum)0;
enumLocal2 = MyEnum.VALUE1;
object enumLocal3 = MyEnum.VALUE2;
object enumLocal4 = new object();
enumLocal4 = MyEnum.VALUE2;
ValueType enumLocal5 = MyEnum.VALUE1;
ValueType enumLocal6 = (MyEnum)0;
enumLocal6 = MyEnum.VALUE2;
}
static void Main(string[] args)
{
//Если мы просто указывааем константу - выводится ее имя.
//Если мы указываем константу с оператором приведения - выводится ее значение.
Console.WriteLine(MyEnum.One); //Ведедется ИМЯ, а НЕ ЗНАЧЕНИЕ
Console.WriteLine((byte)MyEnum.One); //используем оператор явного приведения=> Выведется значение
MyEnum digit = MyEnum.Zero;
Console.WriteLine(digit); //Ведедется ИМЯ, а НЕ ЗНАЧЕНИЕ
Console.WriteLine((byte)digit); //Выведется значение
//Delay
Console.ReadKey();
}
public static void MoreThan64EnumValuesToSerializeWithNamingPolicy()
{
var options = new JsonSerializerOptions
{
Converters = { new JsonStringEnumConverter(new ToLowerNamingPolicy()) }
};
for (int i = 0; i < 128; i++)
{
MyEnum value = (MyEnum)i;
string asStr = value.ToString().ToLowerInvariant();
string expected = char.IsLetter(asStr[0]) ? $@"""{asStr}""" : asStr;
Assert.Equal(expected, JsonSerializer.Serialize(value, options));
}
}
public void TestValueInstanceBinding()
{
IDIContext context = ContextHelper.CreateContext();
context.s().BindInstance <int>(5);
int i = context.Resolve <int>();
Assert.AreEqual(5, i);
context.s().BindInstance <MyEnum>(MyEnum.Viktoria);
MyEnum name = context.Resolve <MyEnum>();
Assert.AreEqual(MyEnum.Viktoria, name);
}
public static void MultipleRet(MyEnum e)
{
switch (e)
{
case MyEnum.Opt1:
Console.WriteLine("Opt1");
break;
case MyEnum.Opt3:
Console.WriteLine("Opt3");
break;
default:
Console.WriteLine("Whatever!");
break;
}
}
public void OptionalParamDefaultValues(
bool boolParam = true,
byte byteParam = 42,
char charParam = 'a',
double doubleParam = 1.0,
MyEnum enumParam = MyEnum.All,
float floatParam = (float)1.0,
int intParam = 42,
long longParam = 42,
object objectParam = null,
short shortParam = 42,
string stringParam = "abc"
)
{
}
public void testing()
{
// Initialize with two flags using bitwise OR.
MyEnum workingFlags = MyEnum.Value1 | MyEnum.Value3;
// Set an additional flag using bitwise OR.
workingFlags = workingFlags | MyEnum.Value4;
// workingFlags: Value1, Value3, Value4
// Remove a flag using bitwise XOR.
workingFlags = workingFlags ^ MyEnum.Value3;
// workingFlags: Value1, Value4
// Test value of flags using bitwise AND.
bool test = (workingFlags & MyEnum.Value3) == MyEnum.Value3;
// test = true;
}
public static string EnumValue(this MyEnum e)
{
switch (e)
{
case MyEnum.First:
return("First Friendly Value");
case MyEnum.Second:
return("Second Friendly Value");
case MyEnum.Third:
return("Third Friendly Value");
}
return("Horrible Failure!!");
}
static void Main(string[] args)
{
Console.WriteLine("Input one of these colors");
for (MyEnum number = MyEnum.Red; number <= MyEnum.Green; number++)
{
Console.Write("{0} = {0:D} ", number);
}
Console.WriteLine();
int color = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Input string");
string str = Console.ReadLine();
MyClass.Print(str, color);
}
public PrimitiveMessage(
bool? mBool,
sbyte? mByte,
short? mShort,
int? mInt,
long? mLong,
double? mDouble,
MyEnum? mEnum
) {
this.MBool = mBool;
this.MByte = mByte;
this.MShort = mShort;
this.MInt = mInt;
this.MLong = mLong;
this.MDouble = mDouble;
this.MEnum = mEnum;
}
public static void Main (string[] args) {
MyEnum? e1 = MyEnum.A;
MyEnum? e2 = null;
Console.WriteLine(e1.Value.ToString());
Console.WriteLine(e2.GetValueOrDefault(MyEnum.B).ToString());
NE = e2;
E = e1.Value;
Console.WriteLine((int)(E));
NE = e1;
E = e2.GetValueOrDefault(MyEnum.C);
Console.WriteLine((int)(NE.Value));
Console.WriteLine((int)(E));
}
public void InjectPropertieswithEnumWorksAsExpected()
{
// --- Arrange
var settings = new PropertySettingsCollection(
new List<PropertySettings>
{
new PropertySettings("Entry", EventLogEntryType.Error.ToString()),
}
);
// --- Act
object myEnum = new MyEnum();
ConfigurationHelper.InjectProperties(ref myEnum, settings);
// --- Assert
var asEnum = (MyEnum)myEnum;
asEnum.Entry.ShouldEqual(EventLogEntryType.Error);
}
public int Switch(MyEnum e)
{
var i = 0;
switch (e)
{
case MyEnum.One:
i += 1;
break;
case MyEnum.Two:
i += 2;
break;
default:
throw Helper.FailedAssertion();
}
return i;
}
public int SwitchWithAssertFalse(MyEnum e)
{
var i = 0;
switch (e)
{
case MyEnum.One:
i += 1;
break;
case MyEnum.Two:
i += 2;
break;
default:
Contract.Assert(false);
throw new Exception();
}
return i;
}
void Casey(MyEnum me)
{
switch (me)
{
case MyEnum.Default:
// some code...
break;
case MyEnum.One:
// some code...
break;
case MyEnum.Two:
// some code...
break;
case MyEnum.Three:
// some code...
break;
default:
throw new Exception(string.Format("Invalid option for MyEnum: {0}", me));
}
switch (me)
{
case MyEnum.One:
case MyEnum.Two:
// Do one thing
break;
default:
// Do another thing
break;
}
}
public MyClass Get(string name, int x, int y, MyEnum e)
{
return new MyClass { Name = name, Sum = (x + y) * (int)e };
}
public static void BarRef(out MyEnum o)
{
o = MyEnum.Value;
}
// The string is not one of the known enum values.
public void NotMatch2(MyEnum e)
{
if(e.ToString() == "StringThatDoesn'tMatchTheEnumValue") { }
}
// The call is already correct
public void NotMatch1(MyEnum e)
{
if (e == MyEnum.First) { }
}
// The enum value string need not case match.
// Technically, this ought to be a "statement is always false" as lowercase first
// will never match any MyEnum values.
public void Match3(MyEnum e)
{
if (e.ToString() == "first") { }
}
// ToLower, ToUpper, and Trim (with no params) are all ok on the left hand side.
public void Match2(MyEnum e)
{
if (e.ToString().ToLower() == "first") { }
}
// Simple case.
public void Match1(MyEnum e, NotEnum ne)
{
if (e.ToString() == "First") { }
}
public static char EnumCase(MyEnum me)
{
if(me == MyEnum.A)
{
return 'a';
} else if(me == MyEnum.B) // Should not warn
{
return 'b';
}
else
{
Contract.Assert(false);
throw new Exception();
}
}
public static void UseEnum(MyEnum x)
{
}
public void formatted_enums(MyEnum value)
{
Check.That(() => value == MyEnum.One);
}
public void enums(MyEnum value)
{
}
public void support_int_to_enum_conversion(MyEnum value)
{
}
public void MyTest2(Placeholder control, Visibility visibility, MyEnum myEnum)
{
Output.Write("Method Invoked - MyTest2", "Visibility: " + visibility, "MyEnum: " + myEnum);
}
public JsonResult Get(string name, int x, int y, MyEnum e)
{
return new JsonNetResult(new MyClass { Name = name, Sum = (x + y) * (int)e });
}
public MyEnum EnumParamMethod(MyEnum p)
{
return p;
}
public EnumHolder() : base()
{
this.Enum1 = MyEnum.a;
}
