ScriptableRenderPipeline/Assets/Editor/Tests/ShaderGeneratorTests/ShaderGeneratorTests.cs

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Reflection;
using UnityEngine;
using UnityEditor;
using UnityEngine.Rendering;
using UnityEngine.ScriptableRenderLoop;
using NUnit.Framework;

[TestFixture]
public class ShaderGeneratorTests
{
    struct FailureTypes
    {
        // Non-primitive type in nested struct
        internal struct NestedWithNonPrimitiveType
        {
            public struct Data
            {
                public string s;
            }
            public Data contents;
        }

        // Unsupported primitive type in nested struct
        internal struct UnsupportedPrimitiveType
        {
            public struct Data
            {
                public IntPtr intPtr;
            }
            public Data contents;
        }

        // Mixed types in nested struct
        internal struct MixedTypesInNestedStruct
        {
            public struct Data
            {
                public float f;
                public int i;
            }
            public Data contents;
        }

        // More than 4 primitive fields in nested struct
        internal struct TooManyFields
        {
            public struct Data
            {
                public float f1, f2, f3, f4, f5;
            }
            public Data contents;
        }

        // Merge failure due to incompatible types
        internal struct MergeIncompatibleTypes
        {
            public float f;
            public Vector2 v;
            public int i;
        }

        // Merge failure due to register boundary crossing
        internal struct MergeCrossBoundary
        {
            public Vector2 u;
            public Vector3 v;
        }
    }

    // @TODO:  should probably switch to exceptions...
    static bool HasErrorString(List<string> errors, string errorSubstring)
    {
        if (errors == null)
            return false;

        bool foundError = false;
        foreach (var error in errors)
        {
            if (error.IndexOf(errorSubstring) >= 0)
            {
                foundError = true;
                break;
            }
        }

        return foundError;
    }

    [Test(Description = "Disallow non-primitive types in nested structs")]
    public void Fail_NestedWithNonPrimitiveType()
    {
        string source;
        List<string> errors;

        bool success = CSharpToHLSL.GenerateHLSL(typeof(FailureTypes.NestedWithNonPrimitiveType), new GenerateHLSL(PackingRules.Exact), out source, out errors);
        Assert.IsFalse(success);
        Assert.IsTrue(HasErrorString(errors, "contains a non-primitive field type"));
    }

    [Test(Description = "Check for unsupported types in primitive structs")]
    public void Fail_UnsupportedPrimitiveType()
    {
        string source;
        List<string> errors;

        bool success = CSharpToHLSL.GenerateHLSL(typeof(FailureTypes.UnsupportedPrimitiveType), new GenerateHLSL(PackingRules.Exact), out source, out errors);
        Assert.IsFalse(success);
        Assert.IsTrue(HasErrorString(errors, "contains an unsupported field type"));
    }

    [Test(Description = "Disallow mixed types in nested structs")]
    public void Fail_MixedTypesInNestedStruct()
    {
        string source;
        List<string> errors;

        bool success = CSharpToHLSL.GenerateHLSL(typeof(FailureTypes.MixedTypesInNestedStruct), new GenerateHLSL(PackingRules.Exact), out source, out errors);
        Assert.IsFalse(success);
        Assert.IsTrue(HasErrorString(errors, "contains mixed basic types"));
    }

    [Test(Description = "Disallow more than 16 bytes worth of fields in nested structs")]
    public void Fail_TooManyFields()
    {
        string source;
        List<string> errors;

        bool success = CSharpToHLSL.GenerateHLSL(typeof(FailureTypes.TooManyFields), new GenerateHLSL(PackingRules.Exact), out source, out errors);
        Assert.IsFalse(success);
        Assert.IsTrue(HasErrorString(errors, "more than 4 fields"));
    }

    [Test(Description = "Disallow merging incompatible types when doing aggressive packing")]
    public void Fail_MergeIncompatibleTypes()
    {
        string source;
        List<string> errors;

        bool success = CSharpToHLSL.GenerateHLSL(typeof(FailureTypes.MergeIncompatibleTypes), new GenerateHLSL(PackingRules.Aggressive), out source, out errors);
        Assert.IsFalse(success);
        Assert.IsTrue(HasErrorString(errors, "incompatible types"));
    }

    [Test(Description = "Disallow placing fields across register boundaries when merging")]
    public void Fail_MergeCrossBoundary()
    {
        string source;
        List<string> errors;

        bool success = CSharpToHLSL.GenerateHLSL(typeof(FailureTypes.MergeCrossBoundary), new GenerateHLSL(PackingRules.Aggressive), out source, out errors);
        Assert.IsFalse(success);
        Assert.IsTrue(HasErrorString(errors, "cross register boundary"));
    }
}