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