399 lines
11 KiB
C#
399 lines
11 KiB
C#
using System;
|
|
using NUnit.Framework;
|
|
using HLSLParser;
|
|
|
|
namespace HLSLParserTests
|
|
{
|
|
public static class VariableTests
|
|
{
|
|
#region TestGetTypeModifiersFromEmptyString
|
|
[Test]
|
|
public static void TestGetTypeModifiersFromEmptyString()
|
|
{
|
|
Assert.AreEqual(Variable.GetTypeModifiers(null), new string[0]);
|
|
Assert.AreEqual(Variable.GetTypeModifiers(new ParseTextWalker("")),
|
|
new string[0]);
|
|
}
|
|
#endregion
|
|
|
|
#region TestGetTypeModifiersStringWithoutElement
|
|
[Test]
|
|
public static void TestGetTypeModifiersStringWithoutElement()
|
|
{
|
|
var text = new ParseTextWalker("aaa");
|
|
string[] result = Variable.GetTypeModifiers(text);
|
|
Assert.AreEqual(0, result.Length);
|
|
}
|
|
#endregion
|
|
|
|
#region TestGetTypeModifiersFromStringWithoutSpace
|
|
[Test]
|
|
public static void TestGetTypeModifiersFromStringWithoutSpace()
|
|
{
|
|
var text = new ParseTextWalker("uniform");
|
|
string[] result = Variable.GetTypeModifiers(text);
|
|
Assert.AreEqual(1, result.Length);
|
|
Assert.AreEqual("uniform", result[0]);
|
|
}
|
|
#endregion
|
|
|
|
#region TestGetStorageClassesFrom
|
|
[Test]
|
|
public static void TestGetStorageClassesFrom()
|
|
{
|
|
var text = new ParseTextWalker("uniform extern float4x4 MatrixTransform;");
|
|
string[] result = Variable.GetTypeModifiers(text);
|
|
Assert.AreEqual(2, result.Length);
|
|
Assert.AreEqual("uniform", result[0]);
|
|
Assert.AreEqual("extern", result[1]);
|
|
}
|
|
#endregion
|
|
|
|
#region TestIsVariableFollowing
|
|
[Test]
|
|
public static void TestIsVariableFollowing()
|
|
{
|
|
var text = new ParseTextWalker("int value;");
|
|
bool result = Variable.IsVariableFollowing(text);
|
|
Assert.True(result);
|
|
|
|
text = new ParseTextWalker("int4x4 value;");
|
|
result = Variable.IsVariableFollowing(text);
|
|
Assert.True(result);
|
|
|
|
text = new ParseTextWalker("const int value;");
|
|
result = Variable.IsVariableFollowing(text);
|
|
Assert.False(result);
|
|
}
|
|
#endregion
|
|
|
|
#region TestParseIfVariable
|
|
[Test]
|
|
public static void TestParseIfVariable()
|
|
{
|
|
var text = new ParseTextWalker("int value;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
|
|
text = new ParseTextWalker("uniform const int value;");
|
|
result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
|
|
text = new ParseTextWalker("uniform extern float4x4 MatrixTransform;");
|
|
result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
|
|
text = new ParseTextWalker("PS_IN VS(VS_IN in) { }");
|
|
result = Variable.ParseIfVariable(text);
|
|
Assert.Null(result);
|
|
}
|
|
#endregion
|
|
|
|
#region TestParseTwoVariables
|
|
[Test]
|
|
public static void TestParseTwoVariables()
|
|
{
|
|
string source =
|
|
@"uniform extern float4x4 MatrixTransform;
|
|
|
|
Texture2D<float4> Texture : register(t0);";
|
|
|
|
var text = new ParseTextWalker(source);
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("uniform extern float4x4 MatrixTransform;", result.ToString());
|
|
}
|
|
#endregion
|
|
|
|
#region TestParseIfVariableWithGenericTexture2D
|
|
[Test]
|
|
public static void TestParseIfVariableWithGenericTexture2D()
|
|
{
|
|
string variableSource = "Texture2D<float4> Texture : register(t0);";
|
|
var text = new ParseTextWalker(variableSource);
|
|
var result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("Texture2D<float4>", result.Type);
|
|
Assert.AreEqual("Texture", result.Name);
|
|
Assert.AreEqual("register(t0)", result.Register);
|
|
Assert.AreEqual(variableSource, result.ToString());
|
|
}
|
|
#endregion
|
|
|
|
#region TestfloatVariableParsing
|
|
[Test]
|
|
public static void TestfloatVariableParsing()
|
|
{
|
|
var text = new ParseTextWalker("uniform const float value;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual(2, result.TypeModifiers.Length);
|
|
Assert.AreEqual("float", result.Type);
|
|
}
|
|
#endregion
|
|
|
|
#region TestVectorVariableParsing
|
|
[Test]
|
|
public static void TestVectorVariableParsing()
|
|
{
|
|
var text = new ParseTextWalker("vector<float, 1> value;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("float", result.Type);
|
|
Assert.AreEqual(1, result.Dimensions.Length);
|
|
Assert.AreEqual(1, result.Dimensions[0]);
|
|
|
|
text = new ParseTextWalker("float4 value;");
|
|
result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("float", result.Type);
|
|
Assert.AreEqual(1, result.Dimensions.Length);
|
|
Assert.AreEqual(4, result.Dimensions[0]);
|
|
}
|
|
#endregion
|
|
|
|
#region TestMatrixVariableParsing
|
|
[Test]
|
|
public static void TestMatrixVariableParsing()
|
|
{
|
|
var text = new ParseTextWalker("matrix<float, 1, 3> value;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("float", result.Type);
|
|
Assert.AreEqual(2, result.Dimensions.Length);
|
|
Assert.AreEqual(1, result.Dimensions[0]);
|
|
Assert.AreEqual(3, result.Dimensions[1]);
|
|
|
|
text = new ParseTextWalker("int4x4 value;");
|
|
result = Variable.ParseIfVariable(text);
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual("int", result.Type);
|
|
Assert.AreEqual(2, result.Dimensions.Length);
|
|
Assert.AreEqual(4, result.Dimensions[0]);
|
|
Assert.AreEqual(4, result.Dimensions[1]);
|
|
}
|
|
#endregion
|
|
|
|
#region TestNameParsing
|
|
[Test]
|
|
public static void TestNameParsing()
|
|
{
|
|
var text = new ParseTextWalker("matrix<float, 1, 3> value;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
}
|
|
#endregion
|
|
|
|
#region TestArrayParsing
|
|
[Test]
|
|
public static void TestArrayParsing()
|
|
{
|
|
var text = new ParseTextWalker("int value[15];");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual(15, result.ArraySize);
|
|
}
|
|
#endregion
|
|
|
|
#region TestInitialValueParsing
|
|
[Test]
|
|
public static void TestInitialValueParsing()
|
|
{
|
|
var text = new ParseTextWalker("int value = 4;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("4", result.InitialValue);
|
|
}
|
|
#endregion
|
|
|
|
#region TestInitialValueParsingWithoutValueText
|
|
[Test]
|
|
public static void TestInitialValueParsingWithoutValueText()
|
|
{
|
|
var text = new ParseTextWalker("int value;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual(null, result.InitialValue);
|
|
}
|
|
#endregion
|
|
|
|
#region TestAnnotationsParsing
|
|
[Test]
|
|
public static void TestAnnotationsParsing()
|
|
{
|
|
var text = new ParseTextWalker("int value<float y=1.3;>;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("float y=1.3;", result.Annotations);
|
|
}
|
|
#endregion
|
|
|
|
#region TestAnnotationsParsingWithInitialValue
|
|
[Test]
|
|
public static void TestAnnotationsParsingWithInitialValue()
|
|
{
|
|
var text = new ParseTextWalker("int value<float y=1.3;> = 4;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("float y=1.3;", result.Annotations);
|
|
Assert.AreEqual("4", result.InitialValue);
|
|
}
|
|
#endregion
|
|
|
|
#region TestSemanticParsing
|
|
[Test]
|
|
public static void TestSemanticParsing()
|
|
{
|
|
var text = new ParseTextWalker("int value : COLOR;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("COLOR", result.Semantic);
|
|
}
|
|
#endregion
|
|
|
|
#region TestSemanticParsingWithAnnotations
|
|
[Test]
|
|
public static void TestSemanticParsingWithAnnotations()
|
|
{
|
|
var text = new ParseTextWalker("int value : COLOR<float y=1.3;>;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("COLOR", result.Semantic);
|
|
Assert.AreEqual("float y=1.3;", result.Annotations);
|
|
}
|
|
#endregion
|
|
|
|
#region TestSemanticParsingWithInitialValue
|
|
[Test]
|
|
public static void TestSemanticParsingWithInitialValue()
|
|
{
|
|
var text = new ParseTextWalker("int value : COLOR = 5;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("COLOR", result.Semantic);
|
|
Assert.AreEqual("5", result.InitialValue);
|
|
}
|
|
#endregion
|
|
|
|
#region TestSemanticParsingWithoutSpaces
|
|
[Test]
|
|
public static void TestSemanticParsingWithoutSpaces()
|
|
{
|
|
var text = new ParseTextWalker("int value:COLOR;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("COLOR", result.Semantic);
|
|
}
|
|
#endregion
|
|
|
|
#region TestPackoffsetParsing
|
|
[Test]
|
|
public static void TestPackoffsetParsing()
|
|
{
|
|
var text = new ParseTextWalker("int value : packoffset(c0);");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("packoffset(c0)", result.Packoffset);
|
|
}
|
|
#endregion
|
|
|
|
#region TestRegisterParsing
|
|
[Test]
|
|
public static void TestRegisterParsing()
|
|
{
|
|
var text = new ParseTextWalker("int value : register( ps_5_0, s );");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("register( ps_5_0, s )", result.Register);
|
|
}
|
|
#endregion
|
|
|
|
#region TestRegisterAndAnnotationParsing
|
|
[Test]
|
|
public static void TestRegisterAndAnnotationParsing()
|
|
{
|
|
var text = new ParseTextWalker(
|
|
"int value : register( ps_5_0, s ) <float y=1.3;>;");
|
|
var result = Variable.ParseIfVariable(text);
|
|
|
|
Assert.AreEqual("value", result.Name);
|
|
Assert.AreEqual("register( ps_5_0, s )", result.Register);
|
|
Assert.AreEqual("float y=1.3;", result.Annotations);
|
|
}
|
|
#endregion
|
|
|
|
#region TestToString
|
|
[Test]
|
|
public static void TestToString()
|
|
{
|
|
string variableText = "uniform const int value : COLOR <float y=1.3;> = 5;";
|
|
var walker = new ParseTextWalker(variableText);
|
|
var result = Variable.ParseIfVariable(walker);
|
|
|
|
Assert.AreEqual(variableText, result.ToString());
|
|
}
|
|
#endregion
|
|
|
|
#region TestToStringWithArraySize
|
|
[Test]
|
|
public static void TestToStringWithArraySize()
|
|
{
|
|
string variableText = "uniform const int value[7];";
|
|
var walker = new ParseTextWalker(variableText);
|
|
var result = Variable.ParseIfVariable(walker);
|
|
|
|
Assert.AreEqual(variableText, result.ToString());
|
|
}
|
|
#endregion
|
|
|
|
#region TestToStringWithPackoffset
|
|
[Test]
|
|
public static void TestToStringWithPackoffset()
|
|
{
|
|
string variableText = "uniform const int value : packoffset(c0) = 5;";
|
|
var walker = new ParseTextWalker(variableText);
|
|
var result = Variable.ParseIfVariable(walker);
|
|
|
|
Assert.AreEqual(variableText, result.ToString());
|
|
}
|
|
#endregion
|
|
|
|
#region TestToStringWithRegister
|
|
[Test]
|
|
public static void TestToStringWithRegister()
|
|
{
|
|
string variableText = "uniform const int value : register( vs, s[8] ) = 5;";
|
|
var walker = new ParseTextWalker(variableText);
|
|
var result = Variable.ParseIfVariable(walker);
|
|
|
|
Assert.AreEqual(variableText, result.ToString());
|
|
}
|
|
#endregion
|
|
|
|
#region TestToStringWithDimensions
|
|
[Test]
|
|
public static void TestToStringWithDimensions()
|
|
{
|
|
string variableText = "float4x4 matrix;";
|
|
var walker = new ParseTextWalker(variableText);
|
|
var result = Variable.ParseIfVariable(walker);
|
|
|
|
Assert.AreEqual(variableText, result.ToString());
|
|
}
|
|
#endregion
|
|
}
|
|
}
|