public void ThePrivateStaticPropertyAccess() { var code = ExpressionToCode.ToCode(() => ThePrivateStaticProperty); Assert.Equal("() => ExpressionToCodeLibTest.ThePrivateStaticProperty", code); }
public void UnitW_IsUnit() { var expected = new float4(0, 0, 0, 1); Assert.Equal(expected, float4.UnitW); }
public void Multiply_VectorScalar_Operator(float4 vec, float scale, float4 expected) { var actual = vec * scale; Assert.Equal(expected, actual); }
public void Clamp_TestClamp(float4 vec, float4 min, float4 max, float4 expected) { var actual = float4.Clamp(vec, min, max); Assert.Equal(expected, actual); }
public void Lerp_TestLerp(float4 left, float4 right, float blend, float4 expected) { var actual = float4.Lerp(left, right, blend); Assert.Equal(expected, actual); }
public void Multiply_VectorScalar_Static(float4 vec, float scale, float4 expected) { var actual = float4.Multiply(vec, scale); Assert.Equal(expected, actual); }
public void Min_IsZero(float4 left, float4 right, float4 expected) { var actual = float4.Min(left, right); Assert.Equal(expected, actual); }
public void IsOperator() { Assert.Equal( @"() => new object() is string", ExpressionToCode.ToCode(() => new object() is string)); }
public void SupportsBasicMath() { Assert.Equal(ReplaceThisWithWhatTheRealAnswerShouldBe, 4 * 8); }
public void ComplexGenericName() { Assert.Equal( @"() => ((Func<int, bool>)(x => x > 0))(0)", ExpressionToCode.ToCode(() => ((Func <int, bool>)(x => x > 0))(0))); }
public void DefaultValue() { Assert.Equal( @"() => new TimeSpan(1, 2, 3) == default(TimeSpan)", ExpressionToCode.ToCode(() => new TimeSpan(1, 2, 3) == default(TimeSpan))); }
public void ThisIndexedProperty() { var actual = ExpressionToCode.ToCode(() => this[1]); Assert.Equal("() => this[1]", actual); }
public void ThisStaticMethodCall() { var code = ExpressionToCode.ToCode(() => StaticReturnZero()); Assert.Equal("() => ExpressionToCodeLibTest.StaticReturnZero()", code); }
public void ThisMethodCall() { var code = ExpressionToCode.ToCode(() => ReturnZero()); Assert.Equal("() => ReturnZero()", code); }
public void Add_Static(float4 left, float4 right, float4 expected) { var actual = float4.Add(left, right); Assert.Equal(expected, actual); }
public void Args() { var dictionary = Mock.Of <DictionaryService>(s => s.LookUp("smelt") == "a fish"); Assert.Equal("a fish", dictionary.LookUp("smelt")); }
public void Subtract_Static(float4 left, float4 right, float4 expected) { var actual = float4.Subtract(left, right); Assert.Equal(expected, actual); }
public static void AreEqual(double expected, double actual, double r) { XAssert.Equal(expected, actual, 5); // hack }
public void Divide_Vector_Scalar_Static(float4 vec, float scale, float4 expected) { var actual = float4.Divide(vec, scale); Assert.Equal(expected, actual); }
public static void AreEqual(object expected, object actual, string message = null) { XAssert.Equal(expected, actual); }
public void Max_IsOne(float4 left, float4 right, float4 expected) { var actual = float4.Max(left, right); Assert.Equal(expected, actual); }
public static void AreEqual <T>(T expected, T actual, string message = null) { XAssert.Equal(expected, actual); }
public void NormalizeFast_Static(float4 vec, float4 expected) { var actual = float4.NormalizeFast(vec); Assert.Equal(expected, actual); }
public static void AreEqual <T>(IEnumerable <T> expected, IEnumerable <T> actual) { XAssert.Equal(expected, actual); }
public void Barycentric_Edges(float4 a, float4 b, float4 c, float u, float v, float4 expected) { var actual = float4.BaryCentric(a, b, c, u, v); Assert.Equal(expected, actual); }
public void UnitX_IsUnit() { var expected = new float4(1, 0, 0, 0); Assert.Equal(expected, float4.UnitX); }
public void Subtract_Operator(float4 left, float4 right, float4 expected) { var actual = left - right; Assert.Equal(expected, actual); }
public void NormalizeFast_Instance(float4 vec, float4 expected) { var actual = vec.NormalizeFast(); Assert.Equal(expected, actual); }
public void Zero_IsZero() { var expected = new float4(0, 0, 0, 0); Assert.Equal(expected, float4.Zero); }
public void ThisProtectedWithPrivateSetterPropertyAccess() { var code = ExpressionToCode.ToCode(() => TheProtectedWithPrivateSetterProperty); Assert.Equal("() => TheProtectedWithPrivateSetterProperty", code); }