public void TestValues_basic()
{
var sw = new MemoryStream();
var writer = new BinaryWriter(sw);
DummyStruct[] a = new DummyStruct[]
{
new DummyStruct()
{
v = 1
},
new DummyStruct()
{
v = 2
},
};
writer.WriteValues(a);
var sr = new MemoryStream(sw.ToArray());
var reader = new BinaryReader(sr);
DummyStruct[] b = null;
reader.ReadValues(out b);
Assert.Equal(a, b, new DummyStruct.Comparer());
}
public DerivedClass(DummyStruct dummy)
: base(new DummyStruct {
Value = 10
})
{
Value = 0;
}
public static object checkStruct()
{
var ret = new DummyStruct();
ret.Value = "neo";
return(ret);
}
public void Test_Using_TakeValueUnless_With_A_Null_Predicate()
{
DummyStruct instance = new DummyStruct();
Action action = () => instance.TakeValueUnless(null);
action.Should()
.ThrowExactly <ArgumentNullException>()
.WithMessage($"*predicate*");
}
public override void Setup()
{
base.Setup();
dummyClass = new DummyClass { Value = 1, Reference = "2" };
dummyStruct = new DummyStruct { Value = 3, Reference = "4" };
classValueWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyClass).GetField("Value"));
classReferenceWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyClass).GetField("Reference"));
structValueWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyStruct).GetField("Value"));
structReferenceWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyStruct).GetField("Reference"));
}
public unsafe void FlatBufferBuilder_Add_Array_UnsupportedType_Throws()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
// Construct the data array
var data = new DummyStruct[10];
Assert.Throws <ArgumentException>(() => fbb.Add(data));
}
public void Test_Using_TakeValueUnless_With_A_False_Predicate()
{
DummyStruct instance = new DummyStruct()
{
Value = nameof(instance)
};
DummyStruct?result = instance.TakeValueUnless(inst => inst.Value.Length != 0);
result.HasValue.Should().BeFalse();
}
public void Test_Using_TakeIf_With_A_True_Predicate()
{
DummyStruct instance = new DummyStruct()
{
Value = nameof(instance)
};
DummyStruct?result = instance.TakeIf(inst => inst.Value.Length != 0);
result.HasValue.Should().BeTrue();
result.Value.Should().Be(instance);
}
public void AssertIs_PrimitiveData()
{
var guid1 = new Guid("15b63bc6-9876-4e07-8400-f06daf3e4212");
var guid2 = new Guid("25b63bc6-9876-4e07-8400-f06daf3e4212");
var dummy = new DummyStruct();
new[] {
TestCase(0, target: typeof(Guid), x: guid1, y: guid1),
TestCase(1, target: typeof(Guid), x: guid1, y: dummy, expectedException: typeof(PrimitiveAssertFailedException)), // 値の不一致。
TestCase(2, target: typeof(Guid), x: dummy, y: guid1, expectedException: typeof(PrimitiveAssertFailedException)), // ターゲット型違反。DummyStruct 型は基本データ型ではない。
TestCase(3, target: typeof(Guid), x: guid1, y: guid2, expectedException: typeof(PrimitiveAssertFailedException)), // 値の不一致。
TestCase(10, target: typeof(string), x: guid1, y: guid1, expectedException: typeof(PrimitiveAssertFailedException)), // ターゲット型違反。string 型に Guid 値は割り当てられない。
}.Invoke();
}
public void Empty_structs_should_be_equal()
{
var x = new DummyStruct();
var y = new DummyStruct();
var comparer = ComparerBuilder.Default.GetEqualityComparer <DummyStruct>();
var equality = comparer.Equals(x, y);
var hashX = comparer.GetHashCode(x);
var hashY = comparer.GetHashCode(y);
using (new AssertionScope()) {
equality.Should().BeTrue();
hashX.Should().Be(hashY);
}
}
public void TestValues_empty()
{
var sw = new MemoryStream();
var writer = new BinaryWriter(sw);
DummyStruct[] a = new DummyStruct[0];
writer.WriteValues(a);
var sr = new MemoryStream(sw.ToArray());
var reader = new BinaryReader(sr);
DummyStruct[] b = null;
reader.ReadValues(out b);
Assert.Empty(b);
}
public static void Alloc()
{
var w1 = Stopwatch.StartNew();
var rnd = new Random();
while (true)
{
var alloc = rnd.Next(100000, 10000000);
var x = new DummyStruct[alloc];
x[0].A = 1;
x[x.Length - 1].A = 2;
if (w1.Elapsed > TimeSpan.FromSeconds(15))
{
break;
}
}
}
public unsafe void FlatBufferBuilder_Add_IntPtr_UnsupportedType_Throws()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
// Construct the data array
var array = new DummyStruct[10];
fixed(DummyStruct *ptr = array)
{
var data = (IntPtr)ptr;
var length = 10 * sizeof(DummyStruct);
Assert.Throws <ArgumentException>(() => fbb.Add <DummyStruct>(data, length));
}
}
public static void SetValue()
{
try
{
// BOOl
s_StaticBoolUser.value = false;
s_StaticBoolProject.value = false;
Assert.IsFalse((bool)s_StaticBoolUser);
Assert.IsFalse((bool)s_StaticBoolProject);
// STRING
s_StaticStringUser.value = "Some more text";
s_StaticStringProject.value = "Some text here";
Assert.AreEqual("Some more text", (string)s_StaticStringUser);
Assert.AreEqual("Some text here", (string)s_StaticStringProject);
// STRUCT
var userStruct = new DummyStruct("Changed text", 23);
var projectStruct = new DummyStruct("Slightly different text", -9825);
s_StaticStructUser.SetValue(userStruct);
s_StaticStructProject.SetValue(projectStruct);
Assert.AreEqual(userStruct, (DummyStruct)s_StaticStructUser);
Assert.AreEqual(projectStruct, (DummyStruct)s_StaticStructProject);
// CLASS
var userClass = new DummyClass("Changed text", 23);
var projectClass = new DummyClass("Slightly different text", -9825);
s_StaticClassUser.SetValue(userClass);
s_StaticClassProject.SetValue(projectClass);
Assert.AreEqual(userClass, (DummyClass)s_StaticClassUser);
Assert.AreEqual(projectClass, (DummyClass)s_StaticClassProject);
}
catch (Exception e)
{
Debug.LogError(e.ToString());
}
}
public void DefaultKeywordTest()
{
Assert.False(GetDefaultValue <bool>());
Assert.Equal(0, GetDefaultValue <int>());
Assert.Equal(0.0f, GetDefaultValue <float>());
Assert.True(null == GetDefaultValue <string>(), "reference type은 null");
// struct인 경우 member들마다 default() 리턴값으로 할당
DummyStruct s = GetDefaultValue <DummyStruct>();
Assert.False(s.boolMember);
Assert.Equal(0, s.intMember);
Assert.Equal(0.0f, s.floatMember);
Assert.Null(s.referenceMember);
// Nullable도 똑같은 규칙 적용
Nullable <int> defaultNullable = GetDefaultValue <Nullable <int> >();
Assert.False(defaultNullable.HasValue);
}
public void TestValue()
{
var sw = new MemoryStream();
var writer = new BinaryWriter(sw);
DummyStruct a = new DummyStruct()
{
v = 123
};
writer.WriteValue(a);
var sr = new MemoryStream(sw.ToArray());
var reader = new BinaryReader(sr);
DummyStruct b = new DummyStruct();
reader.ReadValue(ref b);
Assert.Equal(a, b, new DummyStruct.Comparer());
}
public override void Setup()
{
base.Setup();
dummyClass = new DummyClass();
dummyStruct = new DummyStruct();
classMethod1Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method1"));
classMethod2Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method2"));
classMethod3Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method3"));
classMethod4Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method4"));
classMethod5Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method5"));
classMethod6Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method6"));
classMethod7Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method7"));
classMethod8Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyClass).GetMethod("Method8"));
structMethod1Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method1"));
structMethod2Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method2"));
structMethod3Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method3"));
structMethod4Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method4"));
structMethod5Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method5"));
structMethod6Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method6"));
structMethod7Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method7"));
structMethod8Wrapper = ReflectionUtility.CreateMethodWrapper(typeof(DummyStruct).GetMethod("Method8"));
}
public DerivedClass(DummyStruct s)
: base(default(DummyStruct)) {
Value = 0;
}
public void A(DummyStruct arg1)
{
}
public void GetDescriptionThrowsArgumentExceptionIfArgumentIsNotAnEnum()
{
DummyStruct dummy = new DummyStruct();
TestUtils.ExpectException<ArgumentException>(() => dummy.GetDescription());
}
public DerivedClass(DummyStruct dummy, double i)
: base(new DummyStruct(10))
{
Value = 0;
}
public void GetDescriptionThrowsArgumentExceptionIfArgumentIsNotAnEnum()
{
DummyStruct dummy = new DummyStruct();
TestUtils.ExpectException <ArgumentException>(() => dummy.GetDescription());
}
public DerivedClass(DummyStruct dummy, int i)
: base(new DummyStruct(10) { Value = 20 })
{
Value = 0;
}
public DerivedClass(DummyStruct dummy)
: base(new DummyStruct { Value = 10 }) {
Value = 0;
}
public DerivedClass(DummyStruct s)
: base(default(DummyStruct))
{
Value = 0;
}
public DerivedClass(DummyStruct dummy, int i)
: base(new DummyStruct(10) { Value = 20 }) {
Value = 0;
}
public DerivedClass(DummyStruct dummy, double i)
: base(new DummyStruct(10)) {
Value = 0;
}
