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; }