public void OnGUI()
{
string[] strs = new[]
{
"数组下标0",
"数组下标1",
"数组下标2",
};
int[] intArr = new[]
{
1,
2,
3,
};
//字符选择，返回选择的字符数组下标
this.index = EditorGUILayout.Popup(this.index, strs);
//字符选择，返回对应的整数数组的整数值
this.index = EditorGUILayout.IntPopup(this.index, strs, intArr);
Debug.Log("index:" + index);
//枚举选择
this.mEnum = (EnumTest)EditorGUILayout.EnumPopup(this.mEnum);
}
public void resetProperties()
{
testVar_0 = -1;
testVar_1 = -1;
testVar_2 = -1.0f;
testVar_3 = -1.0f;
event_test_var_int = -1;
event_test_var_bool = false;
event_test_var_float = -1.0f;
event_test_var_agent = null;
waiting_timeout_interval = 0;
action_0_enter_count = 0;
action_0_exit_count = 0;
action_1_enter_count = 0;
action_1_exit_count = 0;
action_2_enter_count = 0;
action_2_exit_count = 0;
m_bCanSee = false;
m_bTargetValid = false;
testColor = EnumTest.EnumTest_One;
testVar_str_0 = string.Empty;
this.Variables.Clear();
}
/**
* main.
*
* @param args
*/
public static void main(string[] args)
{
int nbTests = (args != null && args.Length >= 1) ? int.Parse(args[0]) : NB_TESTS;
int nbOfExclusionMinMax = (args != null && args.Length >= 2) ? int.Parse(args[1]) : NB_OF_EXCLUSION_MIN_MAX;
List <long> executionTimes = new List <long>(nbTests);
for (int i = nbTests; i != 0; i--)
{
executionTimes.Add(EnumTest.testEnumGetValues());
}
executionTimes.Sort();
Console.WriteLine("[EnumTest], Invoke of " + NB_ENUM_TESTS + " Number[] numbers = (Number[]) Enum.GetValues(typeof(Number)),, average time,"
+ averageTimeWithoutMinMax(executionTimes, nbOfExclusionMinMax) + ", min time," + executionTimes[0] + ", max time," + executionTimes[executionTimes.Count - 1]
+ ", relative deviation time," + relativeDeviationTimeWithoutMinMax(executionTimes, nbOfExclusionMinMax));
executionTimes.Clear();
for (int i = nbTests; i != 0; i--)
{
executionTimes.Add(EnumTest.testEnumParseAndSwitch());
}
executionTimes.Sort();
Console.WriteLine("[EnumTest], Invoke of " + NB_ENUM_PARSE_SWITCH_TESTS + " Number number = (Number) Enum.Parse(typeof(Number) \"ONE\") switch (number)...,, average time,"
+ averageTimeWithoutMinMax(executionTimes, nbOfExclusionMinMax) + ", min time," + executionTimes[0] + ", max time," + executionTimes[executionTimes.Count - 1]
+ ", relative deviation time," + relativeDeviationTimeWithoutMinMax(executionTimes, nbOfExclusionMinMax));
executionTimes.Clear();
}
static void Main(string[] args)
{
var test = new EnumTest();
test.ConsumeEnumerable2Times();
Console.ReadKey();
}
public ConditionalAttribute(string valueSource, int valueAsInt, EnumTest test) : base(TestPhase, 0)
{
ValueSource = valueSource;
IntValue = valueAsInt;
EnumTest = test;
Type = TestType.Enum;
}
public void Should_Get_Enum_Description(int numb, string desc)
{
EnumTest enumVar = (EnumTest)numb;
string enumDescription = enumVar.GetDescription();
Assert.Equal(desc, enumDescription);
}
public int[] TestBooks(int[] points, EnumTest testCase)
{
List <Book> list = new List <Book>();
foreach (var point in points)
{
list.Add(new Book(point));
}
BinarySearchTree <Book> tree = new BinarySearchTree <Book>(list.ToArray());
SetComparer(tree, testCase);
int[] array = new int[list.Count];
list.Clear();
foreach (var node in tree.Preorder())
{
list.Add(node.Value);
}
for (int i = 0; i < list.Count; i++)
{
array[i] = list[i].Year;
}
return(array);
}
public void GenerateDoubleToEnumConverter()
{
Func <double, EnumTest> converter = ReflectionHelper.GenerateFromDoubleConverter <EnumTest>();
EnumTest value = converter(12);
Assert.Equal(EnumTest.Value, value);
}
public static void SetComparer <T>(BinarySearchTree <T> tree, EnumTest enumTest)
{
switch (enumTest)
{
case EnumTest.Book:
tree.SetComparer(new StringComparer <T>());
break;
case EnumTest.String:
tree.SetComparer(new StringComparer <T>());
break;
case EnumTest.Int:
tree.SetComparer(new StringComparer <T>());
break;
case EnumTest.Point:
tree.SetComparer(new StringComparer <T>());
break;
case EnumTest.Default:
tree.SetComparer(new DefaultComparer <T>());
break;
}
}
public void InnerEnumIntegerInstanceTest()
{
EnumTest enumTest = new EnumTest();
enumTest.EnumIntegerOnly = EnumTest.EnumIntegerOnlyEnum.NUMBER_2;
enumTest.EnumInteger = EnumTest.EnumIntegerEnum.NUMBER_MINUS_1;
Assert.Equal("{\"enum_integer\":-1,\"enum_integer_only\":2,\"outerEnum\":null}", JsonConvert.SerializeObject(enumTest));
}
public void GetValues_ShouldReturnCorrectValues()
{
//act
var actual = EnumHelper.GetValues<EnumTest>();
var expected = new EnumTest[] {EnumTest.Value1, EnumTest.Value2, EnumTest.Value3};
actual.ShouldAllBeEquivalentTo(expected);
}
private string OneEnumParameterMethod(EnumTest enumTest)
{
switch (enumTest)
{
case EnumTest.Apa:
return("apa");
}
return(null);
}
public void EqualsMethod()
{
Assert.True(EnumTest.Item1.Equals(EnumTest.FromName <EnumTest>("Item 1")));
Assert.True(EnumTest.Item1.Equals(EnumTest.FromId <EnumTest>(0)));
Assert.True(EnumTest.Item1.Equals(new EnumTest(0, "teste")));
Assert.False(EnumTest.Item1.Equals(null));
Assert.False(EnumTest.Item1.Equals(EnumTest.FromName <EnumTest>("Item 2")));
Assert.False(EnumTest.Item1.Equals(EnumTest.FromId <EnumTest>(1)));
Assert.False(EnumTest.Item1.Equals(new EnumTest(1, "teste")));
}
public void CloneEnum()
{
var input = new EnumTest()
{
TestEnum = EnumTest.MyEnum.b,
};
var output = _serializer.Clone(log, input);
Assert.AreEqual(output.TestEnum, input.TestEnum);
}
public void SerializeEnum()
{
var input = new EnumTest
{
TestEnum = MyEnum.b
};
_serializer.Save(Call, input);
EnumTest output = _serializer.Load <EnumTest>(Call);
Assert.AreEqual(output.TestEnum, input.TestEnum);
}
static void Main()
{
EnumTest tstEnum = EnumTest.Unknown;
object objTestEnum;
objTestEnum = Enum.Parse(tstEnum.GetType(), "EnumThree");
if (objTestEnum is EnumTest)
{
EnumTest newTestEnum = (EnumTest)objTestEnum;
Console.WriteLine("newTestEnum = {0}", newTestEnum.ToString());
}
}
public void NotEqualOperator()
{
Assert.True(EnumTest.Item1 != EnumTest.FromName <EnumTest>("Item 2"));
Assert.True(EnumTest.Item1 != EnumTest.FromId <EnumTest>(1));
Assert.True(EnumTest.Item1 != new EnumTest(1, "teste xx"));
Assert.True(null != EnumTest.FromName <EnumTest>("Item 2"));
Assert.True(EnumTest.Item1 != null);
Assert.False(((EnumTest)null) != (EnumTest)null);
Assert.False(EnumTest.Item1 != EnumTest.FromName <EnumTest>("Item 1"));
Assert.False(EnumTest.Item1 != EnumTest.FromId <EnumTest>(0));
Assert.False(EnumTest.Item1 != new EnumTest(0, "teste xx"));
}
public void ParseTo_Value_WhiteSpace()
{
// arrange
var value = Fake.StringWhiteSpace;
// act
var result = ParseTo <EnumTest>(value);
// assert
const EnumTest resultExpected = EnumTest.Unknown;
result.Should().Be(resultExpected);
}
public void ParseTo_Valid()
{
// arrange
const string value = "Test";
// act
var result = ParseTo <EnumTest>(value);
// assert
const EnumTest resultExpected = EnumTest.Test;
result.Should().Be(resultExpected);
}
public void ParseTo_Value_Alternative_Without_AlternativeName()
{
// arrange
const string value = "Teste";
// act
var result = ParseTo <EnumTest>(value);
// assert
const EnumTest resultExpected = EnumTest.Unknown;
result.Should().Be(resultExpected);
}
public void EqualOperator()
{
Assert.True(EnumTest.Item1 == EnumTest.FromName <EnumTest>("Item 1"));
Assert.True(EnumTest.Item1 == EnumTest.FromId <EnumTest>(0));
Assert.True(EnumTest.Item1 == new EnumTest(0, "teste"));
Assert.True(((EnumTest)null) == (EnumTest)null);
Assert.False(null == EnumTest.FromName <EnumTest>("Item 2"));
Assert.False(EnumTest.Item1 == null);
Assert.False(EnumTest.Item1 == EnumTest.FromName <EnumTest>("Item 2"));
Assert.False(EnumTest.Item1 == EnumTest.FromId <EnumTest>(1));
Assert.False(EnumTest.Item1 == new EnumTest(1, "teste"));
}
public void ParseTo_Value_Lower()
{
// arrange
var value = "Test".ToLower();
// act
var result = ParseTo <EnumTest>(value);
// assert
const EnumTest resultExpected = EnumTest.Test;
result.Should().Be(resultExpected);
}
public int[] TestInt(int[] points, EnumTest testCase)
{
BinarySearchTree <int> tree = new BinarySearchTree <int>(points);
SetComparer(tree, testCase);
List <int> list = new List <int>();
foreach (var node in tree.Inorder())
{
list.Add(node.Value);
}
return(list.ToArray());
}
static void TraverseAllValueDemo()
{
foreach (EnumTest e in Enum.GetValues(typeof(EnumTest)))
{
Console.WriteLine(e);
}
EnumTest three = EnumTest.One | EnumTest.One | EnumTest.Two;
foreach (EnumTest e in Enum.GetValues(three.GetType()))
{
Console.WriteLine(e);
}
}
public TestClass() {
AccModTest = new AccessModifierTest();
ArrTest = new ArrayTest();
ETest = new EnumTest();
IdentTest = new IdentifierTest();
MethTest = new MethodTest();
SpecExpTest = new SpecialExpressionsTest();
AssignTest = new AssignmentTest();
OpEqTest = new OpEqTest();
Suffixes = new Suffixes();
Constants = new TermConstants();
Override = new OverrideTest();
OpOver1 = new OpOverload();
OpOver2 = new OpOverload();
}
public void GetAll()
{
System.Collections.Generic.List <EnumTest> enuns = EnumTest.GetAll <EnumTest>();
Assert.Same(EnumTest.Item1, enuns[0]);
Assert.Same(EnumTest.Item2, enuns[1]);
Assert.Same(EnumTest.Item3, enuns[2]);
// Obtendo novamente, mas com os itens já em memória
enuns = EnumTest.GetAll <EnumTest>();
Assert.Same(EnumTest.Item1, enuns[0]);
Assert.Same(EnumTest.Item2, enuns[1]);
Assert.Same(EnumTest.Item3, enuns[2]);
}
public string[] TestString(EnumTest testCase)
{
string[] points = new string[] { "c", "b", "a", "d", "e" };
List <string> list = new List <string>();
BinarySearchTree <string> tree = new BinarySearchTree <string>(points);
SetComparer(tree, testCase);
foreach (var node in tree.Postorder())
{
list.Add(node.Value);
}
return(list.ToArray());
}
public TestClass()
{
AccModTest = new AccessModifierTest();
ArrTest = new ArrayTest();
ETest = new EnumTest();
IdentTest = new IdentifierTest();
MethTest = new MethodTest();
SpecExpTest = new SpecialExpressionsTest();
AssignTest = new AssignmentTest();
OpEqTest = new OpEqTest();
Suffixes = new Suffixes();
Constants = new TermConstants();
Override = new OverrideTest();
OpOver1 = new OpOverload();
OpOver2 = new OpOverload();
}
static void TraverseDemo()
{
// It is the reason of setting int 1, 2, 4, 8... for an enum:
// We can combine multiple states with the "|" operator
EnumTest three = EnumTest.One | EnumTest.One | EnumTest.Two;
// If there is not [Flags] tab, here will print "3".
Console.WriteLine(three.ToString());
foreach (EnumTest e in Enum.GetValues(three.GetType()))
{
if (three.HasFlag(e))
{
Console.WriteLine(e);
}
}
}
/// <summary>
/// 随机字段
/// </summary>
public override void RandomField()
{
if (HasRandom)
{
return;
}
HasRandom = true;
System.Random random = new System.Random();
ParentField = random.Next(int.MinValue, int.MaxValue);
BoolVal = random.Next(0, 2) == 0;
ByteVal = (byte)random.Next(byte.MinValue, byte.MaxValue);
CharVal = (char)random.Next('\u4E00', '\u9FA5');
DecimalVal = (decimal)random.Next(int.MinValue, int.MaxValue);
DoubleVal = (double)random.Next(int.MinValue, int.MaxValue);
EnumVal = (EnumTest)random.Next((int)EnumTest.A, (int)EnumTest.E);
FloatVal = (float)random.Next(int.MinValue, int.MaxValue);
IntVal = random.Next(int.MinValue, int.MaxValue);
LongVal = (long)random.Next(int.MinValue, int.MaxValue);
SByteVal = (sbyte)random.Next(sbyte.MinValue, sbyte.MaxValue);
ShortVal = (short)random.Next(short.MinValue, short.MaxValue);
StringVal = random.Next(int.MinValue, int.MaxValue).ToString();
UIntVal = (uint)random.Next(0, int.MaxValue);
ULongVal = (ulong)random.Next(0, int.MaxValue);
UShortVal = (ushort)random.Next(ushort.MinValue, ushort.MaxValue);
MaterialVal = AssetDatabase.LoadMainAssetAtPath(random.Next(0, 2) == 0? Const_PathMaterialB : Const_PathMaterialC) as Material;
NonSerializedInt = random.Next(int.MinValue, IntValDefault);
SerializableVal.RandomField();
ArrayVal = new Test_ToXmlOther[random.Next(2, 6)];
for (int i = 0; i < ArrayVal.Count(); i++)
{
ArrayVal[i] = new Test_ToXmlOther();
ArrayVal[i].RandomField();
}
ListVal = new List <Test_ToXmlOther>();
for (int i = 0; i < random.Next(2, 6); i++)
{
ListVal.Add(new Test_ToXmlOther());
ListVal[i].RandomField();
}
DictionaryVal = new Dictionary <int, Test_ToXmlOther>();
for (int i = 0; i < random.Next(2, 6); i++)
{
DictionaryVal.Add(i, new Test_ToXmlOther());
DictionaryVal[i].RandomField();
}
}
static void Main(string[] args)
{
CircularBuffer <double> buff = new CircularBuffer <double>(5);
buff.Add(1);
buff.Add(2);
buff.ChangeCapacity(3);
buff.Add(3);
buff.Add(4);
buff.Add(5);
buff.ChangeCapacity(4);
buff.Add(6);
buff.Add(7);
buff.Add(8);
foreach (double d in buff)
{
Console.WriteLine(d);
}
DataStore store = new DataStore();
store.Create <bool>("test1", false);
store.Set <string>("test1", "true");
bool test1 = store.Get <bool>("test1");
store.Create <string>("test2", "true");
bool test = store.Get <bool>("test2");
foreach (EnumTest et in EnumTest.GetValues())
{
Console.WriteLine(et);
}
Console.ReadLine();
LogManager.Start();
Console.ReadLine();
LogManager.WriteTraceMessage("Test trace message");
LogManager.WriteDebugMessage("Test debug message");
LogManager.WriteInfoMessage("Test info message");
Console.ReadLine();
LogManager.WriteSuccessMessage("Test success message");
LogManager.WriteWarningMessage("Test warning message");
LogManager.WriteErrorMessage("Test error message");
LogManager.WriteFatalMessage("Test fatal message");
LogManager.Stop();
Console.ReadLine();
}
public void Init()
{
instance = new EnumTest();
}
// the content of your window draw here.
void OnGUI()
{
// GUILayout.Button
m_FoldOut3 = EditorGUILayout.Foldout( m_FoldOut3 , "Fold Out 3" ) ;
if( true == m_FoldOut3 )
{
// HelpBox
EditorGUILayout.HelpBox( "Help Box MessageType.Error" , MessageType.Error ) ;
EditorGUILayout.HelpBox( "Help Box MessageType.Info" , MessageType.Info ) ;
EditorGUILayout.HelpBox( "Help Box MessageType.None" , MessageType.None ) ;
EditorGUILayout.HelpBox( "Help Box MessageType.Warning" , MessageType.Warning ) ;
}
EditorGUILayout.Space() ;
EditorGUILayout.LabelField( "This is a label, the length is unlimited." ) ;
EditorGUILayout.LabelField( "The Lord of the Rings.........123456" , "The Fellowship of the Ring." ) ;
EditorGUILayout.PrefixLabel( "Prefix Label , the same as LabelField at EditorGUILayout" ) ;
EditorGUILayout.SelectableLabel( "Selectable Label, Select me please." ) ;
m_Bound = EditorGUILayout.BoundsField( "This is Bound , James Bound." , m_Bound ) ;
// m_Bound.Contains
// EditorGUILayout.SelectableLabel( "Selectable Label, Select me please." ) ;
// m_Bound = EditorGUILayout.BoundsField( "This is Bound , James Bound." , m_Bound ) ;
m_RectFieldValue = EditorGUILayout.RectField( "RectField" , m_RectFieldValue ) ;
EditorGUILayout.Separator() ;
m_Vector2 = EditorGUILayout.Vector2Field( "Vector2" , m_Vector2 ) ;
m_Vector3 = EditorGUILayout.Vector3Field( "Vector3" , m_Vector3 ) ;
m_Vector4 = EditorGUILayout.Vector4Field( "Vector4" , m_Vector4 ) ;
EditorGUILayout.Separator() ;
m_Color = EditorGUILayout.ColorField( "ColorField" , m_Color ) ;
m_AnimationCurve = EditorGUILayout.CurveField( "Animation Curve" , m_AnimationCurve ) ;
// int(32bit=4byte) 00000000 00000000 00000000 00000000
// 0 0
// on off
// nothing 00
// everything 11
// on 10
// off 01
//
// current |(OR) off
// 10 | 01 => 11
// current &(AND) off
// 10 & 01 => 00
m_EnumTest1 = (EnumTest) EditorGUILayout.EnumMaskField( "Enum Mask Field" , m_EnumTest1 ) ;
m_EnumTest2 = (EnumTest) EditorGUILayout.EnumPopup( "Enum Pop Up" , m_EnumTest2 ) ;
m_FloatValue = EditorGUILayout.FloatField( "Float Field" , m_FloatValue ) ;
EditorGUILayout.Separator() ;
m_FoldOut0 = EditorGUILayout.Foldout( m_FoldOut0 , "Fold Out 0" ) ;
if( true == ( m_FoldOut1 = EditorGUILayout.Foldout( m_FoldOut1 , "Fold Out" ) ) )
// m_FoldOut1 = EditorGUILayout.Foldout( m_FoldOut1 , "Fold Out" ) ;
{
m_IntPopupOptionValue = EditorGUILayout.IntPopup( "IntPopup" ,
m_IntPopupOptionValue ,
m_DisplayOption ,
m_DisplayOptionValue ) ;
EditorGUILayout.IntField( "IntPopup Value" , m_IntPopupOptionValue ) ;
m_GenericPopupIndexValue =
EditorGUILayout.Popup( "Popup" ,
m_GenericPopupIndexValue ,
m_DisplayOption ) ;
EditorGUILayout.IntField( "Popup Value" , m_GenericPopupIndexValue ) ;
// nothing 00000000 00000000 00000000 00000000 = 0
// Plan A 00000000 00000000 00000000 00000001 = 1
// Plan B 00000000 00000000 00000000 00000010 = 2
// everything 10000000 00000000 00000000 00000000 = -1
m_MaskValue = EditorGUILayout.MaskField( "This is a mask" ,
m_MaskValue ,
m_DisplayOption ) ;
EditorGUILayout.IntField( "m_MaskValue" , m_MaskValue ) ;
}
EditorGUILayout.Separator() ;
if( 0 != Selection.objects.Length )
{
if( true ==
( m_FoldOut2 = EditorGUILayout.InspectorTitlebar( m_FoldOut2 ,
Selection.objects ) ) )
{
m_IntSliderValue = EditorGUILayout.IntSlider( m_IntSliderValue , 0 , 10 ) ;
m_FloatSliderValue = EditorGUILayout.Slider(
m_FloatSliderValue , -5.0f , 5.0f ) ;
m_LayerValue = EditorGUILayout.LayerField( "This is a layer" , m_LayerValue ) ;
m_TagStr = EditorGUILayout.TagField( "This is a tag" , m_TagStr ) ;
EditorGUILayout.MinMaxSlider(
ref m_MinSliderValue ,
ref m_MaxSliderValue ,
10 , 100 ) ;
EditorGUILayout.FloatField( "m_MinSliderValue" , m_MinSliderValue ) ;
EditorGUILayout.FloatField( "m_MaxSliderValue" , m_MaxSliderValue ) ;
}
}
EditorGUILayout.Separator() ;
if( null != Selection.activeObject )
{
Object anyObject =
EditorGUILayout.ObjectField( "Transform ObjectField" ,
Selection.activeTransform ,
typeof(Transform) ,
true ) ;
if( typeof(Transform) == anyObject.GetType() )
m_SelectTransform = (Transform) anyObject ;
}
if( null != Selection.activeObject )
{
Object anyObject =
EditorGUILayout.ObjectField( "Material Field" ,
Selection.activeObject ,
typeof(Material) ,
false ) ;
if( typeof(Material) == anyObject.GetType() )
{
Material mat = (Material) anyObject ;
}
else
Debug.LogError( anyObject.GetType() ) ;
}
EditorGUILayout.Separator() ;
m_PasswordString = EditorGUILayout.PasswordField( m_PasswordString ) ;
EditorGUILayout.LabelField( "Password String" , m_PasswordString ) ;
EditorGUILayout.Separator() ;
if( true == ( m_Toggle = EditorGUILayout.Toggle( "Toggle TextField&TextArea" , m_Toggle ) ) )
{
m_TextAreaContent = EditorGUILayout.TextArea(
m_TextAreaContent
// , GUILayout.Height( 60 )
) ;
}
m_ToggleGroup = EditorGUILayout.BeginToggleGroup( "Toggle Group" , m_ToggleGroup ) ;
m_TextFieldContent = EditorGUILayout.TextField( "TextField" ,
m_TextFieldContent ,
GUILayout.Height( 60 ) ) ;
EditorGUILayout.EndToggleGroup() ;
}
public CA (EnumTest [] t) { my_enum_array = t; }
public CA (EnumTest t) { my_enum = t; }
/// <summary>
/// Gets a blog post
/// </summary>
/// <param name="id">Id of the blogpost</param>
/// <param name="cheese">nom nom</param>
/// <param name="enumTest">Please work</param>
/// <returns></returns>
public string Get(int id, bool? isABool = false, string cheese = "nom nom", EnumTest enumTest = EnumTest.Hope)
{
return "value";
}
