From 4a1d9dff0feb4b91699d118406a145505aa3c1cd Mon Sep 17 00:00:00 2001 From: Fabrizio Perria Date: Wed, 20 Oct 2021 10:54:07 +0200 Subject: [PATCH 01/50] Provide runtime identifier --- src/Unity.Mathematics/Unity.Mathematics.csproj | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 11383fbb..fa59d06c 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -11,6 +11,7 @@ Unity Unity.Mathematics v4.7.1 + win 512 From 4f846b8ce86bddf054c771e3940eeed92000c5a3 Mon Sep 17 00:00:00 2001 From: Fabrizio Perria Date: Wed, 20 Oct 2021 11:42:40 +0200 Subject: [PATCH 02/50] Revert "Provide runtime identifier" This reverts commit 4a1d9dff0feb4b91699d118406a145505aa3c1cd. --- src/Unity.Mathematics/Unity.Mathematics.csproj | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index fa59d06c..11383fbb 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -11,7 +11,6 @@ Unity Unity.Mathematics v4.7.1 - win 512 From 6c978302ee98bcebadc69a9e8ddb039a8a33f70c Mon Sep 17 00:00:00 2001 From: Fabrizio Perria Date: Wed, 20 Oct 2021 11:43:20 +0200 Subject: [PATCH 03/50] recover burst compatibility --- src/Tests/Unity.Mathematics.Tests.csproj | 2 +- src/Unity.Mathematics.sln | 8 +- src/Unity.Mathematics/Geometry/MinMaxAABB.cs | 4 +- src/Unity.Mathematics/Geometry/Plane.cs | 2 +- .../Properties/AssemblyInfo.cs | 47 ----- .../Unity.Mathematics.csproj | 163 ++---------------- 6 files changed, 18 insertions(+), 208 deletions(-) delete mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj index 4ca36bde..7d9e0d5c 100644 --- a/src/Tests/Unity.Mathematics.Tests.csproj +++ b/src/Tests/Unity.Mathematics.Tests.csproj @@ -103,7 +103,7 @@ - + diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln index 19d5c88a..2e4dadd0 100644 --- a/src/Unity.Mathematics.sln +++ b/src/Unity.Mathematics.sln @@ -28,14 +28,14 @@ Global GlobalSection(ProjectConfigurationPlatforms) = postSolution {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|Any CPU.Build.0 = Debug|Any CPU - {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.ActiveCfg = Debug|x64 - {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.Build.0 = Debug|x64 + {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.ActiveCfg = Debug|Any CPU + {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.Build.0 = Debug|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x86.ActiveCfg = Debug|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x86.Build.0 = Debug|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|Any CPU.ActiveCfg = Release|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|Any CPU.Build.0 = Release|Any CPU - {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.ActiveCfg = Release|x64 - {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.Build.0 = Release|x64 + {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.ActiveCfg = Release|Any CPU + {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.Build.0 = Release|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.ActiveCfg = Release|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.Build.0 = Release|Any CPU {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU diff --git a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs index eb4a3876..6b5b666d 100644 --- a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs +++ b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs @@ -16,7 +16,7 @@ namespace Unity.Mathematics.Geometry /// [System.Serializable] [Il2CppEagerStaticClassConstruction] - internal struct MinMaxAABB : IEquatable + public struct MinMaxAABB : IEquatable { /// /// The minimum point contained by the AABB. @@ -213,7 +213,7 @@ public override string ToString() } } - internal static partial class Math + public static partial class Math { /// /// Transforms the AABB with the given transform. diff --git a/src/Unity.Mathematics/Geometry/Plane.cs b/src/Unity.Mathematics/Geometry/Plane.cs index 92d47c5e..5094bb94 100644 --- a/src/Unity.Mathematics/Geometry/Plane.cs +++ b/src/Unity.Mathematics/Geometry/Plane.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Geometry [DebuggerDisplay("{Normal}, {Distance}")] [Serializable] [Il2CppEagerStaticClassConstruction] - internal struct Plane + public struct Plane { /// /// A plane in the form Ax + By + Cz + Dw = 0. diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs deleted file mode 100644 index c090f5b4..00000000 --- a/src/Unity.Mathematics/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,47 +0,0 @@ -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -#if !UNITY_DOTSPLAYER -using System.Reflection; - -// General Information about an assembly is controlled through the following -// set of attributes. Change these attribute values to modify the information -// associated with an assembly. - -[assembly: AssemblyTitle("Unity.Mathematics")] -[assembly: AssemblyDescription("")] -[assembly: AssemblyConfiguration("")] -[assembly: AssemblyCompany("")] -[assembly: AssemblyProduct("Unity.Mathematics")] -[assembly: AssemblyCopyright("Copyright © 2017")] -[assembly: AssemblyTrademark("")] -[assembly: AssemblyCulture("")] - -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from -// COM, set the ComVisible attribute to true on that type. - -[assembly: ComVisible(false)] - -// The following GUID is for the ID of the typelib if this project is exposed to COM - -[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")] - -// Version information for an assembly consists of the following four values: -// -// Major Version -// Minor Version -// Build Number -// Revision -// -// You can specify all the values or you can default the Build and Revision Numbers -// by using the '*' as shown below: -// [assembly: AssemblyVersion("1.0.*")] - -[assembly: AssemblyVersion("1.0.0.0")] -[assembly: AssemblyFileVersion("1.0.0.0")] -#endif - -[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")] -[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")] -[assembly: InternalsVisibleTo("btests")] \ No newline at end of file diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 11383fbb..43ae5cc1 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -1,162 +1,19 @@ - - - + - Debug - AnyCPU - {19810344-7387-4155-935F-BDD5CC61F0BF} - {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - Library - Properties - Unity - Unity.Mathematics - v4.7.1 - 512 - - - AnyCPU - true - full - false - ..\..\build\bin\Debug\ - DEBUG;TRACE - prompt - 4 - true - true - - - AnyCPU - pdbonly - true - ..\..\build\bin\Release\ - TRACE - prompt - 4 - true - true - - - AnyCPU - true - full - false - ..\..\build\bin\Debug\ - DEBUG;TRACE - prompt - 4 - true - true - - + net471 AnyCPU - pdbonly - true - ..\..\build\bin\Release\ - TRACE - prompt - 4 true - true + false + ..\..\build\bin\$(Configuration)\ - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - + \ No newline at end of file From 0a19cfed4bec15aebf0d4365ecb91308464a07c4 Mon Sep 17 00:00:00 2001 From: Alexandre Mutel Date: Thu, 2 Jul 2020 12:03:09 +0200 Subject: [PATCH 04/50] Fix Unity.Mathematics to stay on version 1.0.0.0 --- src/Unity.Mathematics/Unity.Mathematics.csproj | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 43ae5cc1..f4c7c4e6 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -5,6 +5,8 @@ true false ..\..\build\bin\$(Configuration)\ + + 1.0.0.0 From d67d79f8616c8141e6b18b692c1d1ce952681fbd Mon Sep 17 00:00:00 2001 From: Jo Petty Date: Thu, 23 Jun 2022 11:23:39 +0100 Subject: [PATCH 05/50] Renamed mathematics.md --- src/Documentation~/{mathematics.md => index.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/Documentation~/{mathematics.md => index.md} (100%) diff --git a/src/Documentation~/mathematics.md b/src/Documentation~/index.md similarity index 100% rename from src/Documentation~/mathematics.md rename to src/Documentation~/index.md From 3f6123f3398e3bc020e21347eefbdfc4219a91ce Mon Sep 17 00:00:00 2001 From: Jo Petty Date: Thu, 23 Jun 2022 11:29:12 +0100 Subject: [PATCH 06/50] Added new docs --- src/Documentation~/4x4-matrices.md | 48 ++++++++++++++ src/Documentation~/TableOfContents.md | 4 ++ src/Documentation~/compatibility.md | 15 +++++ src/Documentation~/index.md | 86 +++++------------------- src/Documentation~/mathematics.md.meta | 7 -- src/Documentation~/using-mathematics.md | 87 +++++++++++++++++++++++++ 6 files changed, 171 insertions(+), 76 deletions(-) create mode 100644 src/Documentation~/4x4-matrices.md create mode 100644 src/Documentation~/TableOfContents.md create mode 100644 src/Documentation~/compatibility.md delete mode 100644 src/Documentation~/mathematics.md.meta create mode 100644 src/Documentation~/using-mathematics.md diff --git a/src/Documentation~/4x4-matrices.md b/src/Documentation~/4x4-matrices.md new file mode 100644 index 00000000..05f092b8 --- /dev/null +++ b/src/Documentation~/4x4-matrices.md @@ -0,0 +1,48 @@ +# 4×4 matrices + +To create a 4×4 transformation matrix, use the constructors in [`float4x4`](xref:Unity.Mathematics.float4x4) to assign one value to all elements of the matrix, or individually set all 16 elements directly: + + +```c# +// Unity Mathematics example +void Build4x4UnityMathematics() +{ + var c0 = new float4(1.0f, 0.0f, 0.0f, 0.0f); + var c1 = new float4(0.0f, 1.0f, 0.0f, 0.0f); + var c2 = new float4(0.0f, 0.0f, 1.0f, 0.0f); + var c3 = new float4(0.0f, 0.0f, 0.0f, 1.0f); + var m = new float4x4(c0, c1, c2, c3); +} +``` + +## Multiplying a 4×4 matrix + +Unity Mathematics defines the `*` operator differently to `UnityEngine`. The `*` operator for [`float4x4`](xref:Unity.Mathematics.float4x4) implements componentwise multiplication. If you multiply a `float4x4` of all 1s with 0.5 on the diagonal, you get back the half identity because the upper and lower triangles of the matrix are multiplied by the respective zero entries from `f4x4_HalfIdentity`: + +```c# +// Unity Mathematics example +void OperatorMultiply4x4UnityMathematics() +{ + float4x4 result = f4x4_Ones * f4x4_HalfIdentity; + // result: + // 0.5, 0.0, 0.0, 0.0, + // 0.0, 0.5, 0.0, 0.0, + // 0.0, 0.0, 0.5, 0.0, + // 0.0, 0.0, 0.0, 0.5 +} +``` + +## Multiplying a 4×4 matrix and a 4D vector + +Use the [`math.mul`](xref:Unity.Mathematics.math.mul*) method to multiply a 4×4 matrix and a 4D vector. If you supply a `float4x4` as the first parameter and a `float4` as the second, it performs a 4×4 matrix multiplication with a 4×1 column vector, which returns a 4×1 column vector as a `float4`. + +`math.mul` can also multiply a 1×4 row vector by a 4×4 matrix to produce a 1×4 row vector by taking a `float4` as the first parameter and a `float4×4` as the second. Unity Mathematics stores the row vector in a `float4` and it isn't treated as a separate type. + +```c# +// Unity Mathematics example +void Multiply4x4AndVector4UnityMathematics() +{ + float4 result1 = math.mul(f4x4, f4); // 4x4 * 4x1 = 4x1 + float4 result2 = math.mul(f4, f4x4); // 1x4 * 4x4 = 1x4 +} +``` \ No newline at end of file diff --git a/src/Documentation~/TableOfContents.md b/src/Documentation~/TableOfContents.md new file mode 100644 index 00000000..2907837f --- /dev/null +++ b/src/Documentation~/TableOfContents.md @@ -0,0 +1,4 @@ +* [Unity Mathematics](index.md) +* [Compatibility with Mathf](compatibility.md) +* [Using Unity Mathematics](using-mathematics.md) + * [4×4 matrices](4x4-matrices.md) diff --git a/src/Documentation~/compatibility.md b/src/Documentation~/compatibility.md new file mode 100644 index 00000000..94d6f17c --- /dev/null +++ b/src/Documentation~/compatibility.md @@ -0,0 +1,15 @@ +# Compatibility with `Mathf` + +Unity Mathematics isn't implemented in the same way as the [`UnityEngine.Mathf`](https://docs.unity3d.com/ScriptReference/Mathf.html) struct in the core Unity engine. Because of this, if your application relies on the specific behaviors of `Mathf`, it might not be possible to use Unity Mathematics in your project. Also, if your project uses `Mathf` functions that have no corresponding Unity Mathematics function, or your code uses external plug-ins that depend on Unity types such as `Vector3`, or `Matrix4x4`, then you shouldn't use Unity Mathematics. + +>[!IMPORTANT] +>For performance reasons, if your project uses the Mono compiler, you should continue to use the mathematical operations in `Mathf`, rather than Unity Mathematics. + +## Porting `Mathf` code to Unity Mathematics + +If you want to migrate code from `UnityEngine` to `Unity.Mathematics`, you need to make the following changes first: + +* `Vector4` to `float4` +* Multiplications on vector or matrix objects to component multiplication with the `*` operator. +* Degrees to radians +* How your code generates random numbers \ No newline at end of file diff --git a/src/Documentation~/index.md b/src/Documentation~/index.md index 992642fc..f158d0db 100644 --- a/src/Documentation~/index.md +++ b/src/Documentation~/index.md @@ -1,79 +1,27 @@ -# Unity.Mathematics +# Unity Mathematics -A C# math library providing vector types and math functions with a shader like -syntax. Used by the Burst compiler to compile C#/IL to highly efficient -native code. +Unity Mathematics is a C# math library that provides vector types and math functions that have a shader-like +syntax, similar to [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) or [HLSL](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl). The [Burst compiler](https://docs.unity3d.com/Packages/com.unity.burst@latest) uses Unity Mathematics to compile C#/IL code into highly efficient native code. -The main goal of this library is to provide a friendly Math API familiar to SIMD and graphic/shaders developers, using the well known `float4`, `float3` types...etc. with all intrinsics functions provided by a static class `math` that can be imported easily into your C# program with `using static Unity.Mathematics.math`. +It implements the following vector and matrix types: -In addition to this, the Burst compiler is able to recognize these types and provide the optimized SIMD type for the running CPU on all supported platforms (x64, ARMv7a...etc.) +* floatN, quaternion +* float3×3, float4×4 -NOTICE: The API is a work in progress and we may introduce breaking changes (API and underlying behavior) +Plus elementary functions: +* min, max, fabs, etc. +* sin, cos, sqrt, normalize, dot, cross, etc. -## Usage +## Installation -You can use this library in your Unity game by using the Package Manager and referencing the package `com.unity.mathematics`. See the forum [Welcome](https://forum.unity.com/threads/welcome.522627) page for more details. +You can install the Mathematics package through Unity's Package Manager. For more information, see the Unity User Manual documentation on [Adding and removing packages](https://docs.unity3d.com/Manual/upm-ui-actions.html). -```C# -using static Unity.Mathematics.math; -namespace MyNamespace -{ - using Unity.Mathematics; - - ... - var v1 = float3(1,2,3); - var v2 = float3(4,5,6); - v1 = normalize(v1); - v2 = normalize(v2); - var v3 = dot(v1, v2); - ... -} -``` +### Editor config -## Building +Unity Mathematics uses [editorconfig](http://editorconfig.org/) to keep files formatted for EOL and spaces. -Open the `src\Unity.Mathematics.sln` under Visual Studio 2015 or MonoDevelop and compile in Debug\Release. - -## Contributing - -We don't yet accept PR on this repository. See the FAQ below. - -The project is using [editorconfig](http://editorconfig.org/) to keep files correctly formatted for EOL and spaces. - -We assume that your IDE has support for `editorconfig`, you can download the following extensions if your IDE is listed: - -- [VS2015/VS2017 EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfigTeam.EditorConfig) -- [Visual Studio Code EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) -- [SublimeText EditorConfig extension](https://github.com/sindresorhus/editorconfig-sublime) - -## Frequently Asked Question - -### Why developing another Math library instead of using existing Unity Vector3...etc.? - -After years of feedback and experience with the previous API, we believe that providing an API that is closer to the way graphics developers have been using math libraries should better help its adoption and the ease of its usage. HLSL / GLSL math library is a very well designed, well understood math library leading to greater consistency. - -### Why not using `System.Numerics.Vectors`? - -Mainly for the reason mentioned above, `System.Numerics.Vectors` is in many ways similar to our previous Vector library (more object oriented than graphics programming oriented). -Also the fact that our Burst compiler is able to recognize a lot more patterns for SIMD types and math intrinsics makes it easier to work with a dedicated API that reflects this ability. - -### Naming convention - -In C# `int` and `float` are considered builtin types. Burst extends this set of bultin types to also include vectors, matrices and quaternions. These types are bultin in the sense that Burst knows about them and is be able to generate better code using these types than what would be possible with equivalent code using custom types. - -To signify that these types are bultin their type names are in all lower case. The operators on these bultin types found in `Unity.Mathematics.math` are considered intrinsics and are thus always in lower case. - -There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`). - -This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless. - -### Why can't we send a PR yet? - -We are working on providing a Contributor License Agreement (CLA) with a sign-over functionality and our UCL License doesn't cover this yet. - -## Licensing - -Unity Companion License (“License”) Software Copyright © 2019 Unity Technologies ApS - -For licensing details see [LICENSE.md](LICENSE.md) +Your IDE should have support for `editorconfig`. If it doesn't, you can get the extension for it here: +* [VS2015/VS2017 EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfigTeam.EditorConfig) +* [Visual Studio Code EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) +* [SublimeText EditorConfig extension](https://github.com/sindresorhus/editorconfig-sublime) diff --git a/src/Documentation~/mathematics.md.meta b/src/Documentation~/mathematics.md.meta deleted file mode 100644 index 10f22f41..00000000 --- a/src/Documentation~/mathematics.md.meta +++ /dev/null @@ -1,7 +0,0 @@ -fileFormatVersion: 2 -guid: d177df5c52517492b85d4191425323a9 -TextScriptImporter: - externalObjects: {} - userData: - assetBundleName: - assetBundleVariant: diff --git a/src/Documentation~/using-mathematics.md b/src/Documentation~/using-mathematics.md new file mode 100644 index 00000000..9637b93b --- /dev/null +++ b/src/Documentation~/using-mathematics.md @@ -0,0 +1,87 @@ +# Using Unity Mathematics + +To use Unity Mathematics, add `using Unity.Mathematics` to your code: + +```C# +using static Unity.Mathematics.math; +namespace MyNamespace +{ + using Unity.Mathematics; + + ... + var v1 = float3(1,2,3); + var v2 = float3(4,5,6); + v1 = normalize(v1); + v2 = normalize(v2); + var v3 = dot(v1, v2); + ... +} +``` + +## Naming convention + +In C# `int` and `float` are built-in types. The Burst compiler extends this set of built-in types to also include vectors, matrices, and quaternions. These types are built-in because the Burst compiler already has implementations of these types, and so can use them to generate better code than for custom types. + +To signify that these types are built-in their type names are in all lower case. The operators on these built-in types in [`Unity.Mathematics.math`](xref:Unity.Mathematics.math) are intrinsics and are always in lower case. + +There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`). + +This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless. + + +## Vector multiplication + +To multiply vectors, use the `*`: + +```c# +// Unity Mathematics example +void ComponentwiseVectorMultiplyUnityMathematics() +{ + var v0 = new float4(2.0f, 4.0f, 6.0f, 8.0f); + var v1 = new float4(1.0f, -1.0f, 1.0f, -1.0f); + var result = v0 * v1; + // result == new float4(2.0f, -4.0f, 6.0f, -8.0f). +} +``` + +This is a common way of writing [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) code, which applies a single instruction to multiple data elements. Other operators such as addition, subtraction, and division work in the same way. + +## Quaternion multiplication + +To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors. + +```c# +// Unity Mathematics example +void QuaternionMultiplicationUnityMathematics() +{ + var axis = new float3(0.0f, 1.0f, 0.0f); + var q = quaternion.AxisAngle(axis,math.radians(45.0f)); + var orientation = quaternion.Euler( + math.radians(45.0f), + math.radians(90.0f), + math.radians(180.0f)); + var result = math.mul(q, orientation); +} +``` + +## Random numbers + +To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. + +Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive: + +```c# +// Unity Mathematics example +void RandomNumberUnityMathematics() +{ + // Choose some non-zero seed and set up the random number generator state. + uint seed = 1; + Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed); + + // [0, 1) exclusive + float randomFloat1 = rng.NextFloat(); + + // [-5, 5) exclusive + float randomFloat2 = rng.NextFloat(-5.0f, 5.0f); +} +``` \ No newline at end of file From 802648501b06efab816698a21a07fdee04b9d66b Mon Sep 17 00:00:00 2001 From: Jo Petty Date: Thu, 23 Jun 2022 12:33:07 +0100 Subject: [PATCH 07/50] Reorganised a few pgs --- src/Documentation~/TableOfContents.md | 6 +- src/Documentation~/getting-started.md | 29 +++++++ .../quaternion-multiplication.md | 17 ++++ src/Documentation~/random-numbers.md | 21 +++++ src/Documentation~/using-mathematics.md | 87 ------------------- src/Documentation~/vector-multiplication.md | 16 ++++ 6 files changed, 88 insertions(+), 88 deletions(-) create mode 100644 src/Documentation~/getting-started.md create mode 100644 src/Documentation~/quaternion-multiplication.md create mode 100644 src/Documentation~/random-numbers.md delete mode 100644 src/Documentation~/using-mathematics.md create mode 100644 src/Documentation~/vector-multiplication.md diff --git a/src/Documentation~/TableOfContents.md b/src/Documentation~/TableOfContents.md index 2907837f..1dc7d3b2 100644 --- a/src/Documentation~/TableOfContents.md +++ b/src/Documentation~/TableOfContents.md @@ -1,4 +1,8 @@ * [Unity Mathematics](index.md) * [Compatibility with Mathf](compatibility.md) -* [Using Unity Mathematics](using-mathematics.md) +* [Getting started](getting-started.md) +* Common operations * [4×4 matrices](4x4-matrices.md) + * [Vector multiplication](vector-multiplication.md) + * [Quaternion multiplication](quaternion-multiplication.md) + * [Random numbers](random-numbers.md) diff --git a/src/Documentation~/getting-started.md b/src/Documentation~/getting-started.md new file mode 100644 index 00000000..7ed246e5 --- /dev/null +++ b/src/Documentation~/getting-started.md @@ -0,0 +1,29 @@ +# Getting started + +To use Unity Mathematics, add `using Unity.Mathematics` to your code: + +```C# +using static Unity.Mathematics.math; +namespace MyNamespace +{ + using Unity.Mathematics; + + ... + var v1 = float3(1,2,3); + var v2 = float3(4,5,6); + v1 = normalize(v1); + v2 = normalize(v2); + var v3 = dot(v1, v2); + ... +} +``` + +## Naming convention + +In C# `int` and `float` are built-in types. The Burst compiler extends this set of built-in types to also include vectors, matrices, and quaternions. These types are built-in because the Burst compiler already has implementations of these types, and so can use them to generate better code than for custom types. + +To signify that these types are built-in their type names are in all lower case. The operators on these built-in types in [`Unity.Mathematics.math`](xref:Unity.Mathematics.math) are intrinsics and are always in lower case. + +There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`). + +This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless. diff --git a/src/Documentation~/quaternion-multiplication.md b/src/Documentation~/quaternion-multiplication.md new file mode 100644 index 00000000..b9415b84 --- /dev/null +++ b/src/Documentation~/quaternion-multiplication.md @@ -0,0 +1,17 @@ +# Quaternion multiplication + +To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors. + +```c# +// Unity Mathematics example +void QuaternionMultiplicationUnityMathematics() +{ + var axis = new float3(0.0f, 1.0f, 0.0f); + var q = quaternion.AxisAngle(axis,math.radians(45.0f)); + var orientation = quaternion.Euler( + math.radians(45.0f), + math.radians(90.0f), + math.radians(180.0f)); + var result = math.mul(q, orientation); +} +``` diff --git a/src/Documentation~/random-numbers.md b/src/Documentation~/random-numbers.md new file mode 100644 index 00000000..753108e3 --- /dev/null +++ b/src/Documentation~/random-numbers.md @@ -0,0 +1,21 @@ +## Random numbers + +To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. + +Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive: + +```c# +// Unity Mathematics example +void RandomNumberUnityMathematics() +{ + // Choose some non-zero seed and set up the random number generator state. + uint seed = 1; + Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed); + + // [0, 1) exclusive + float randomFloat1 = rng.NextFloat(); + + // [-5, 5) exclusive + float randomFloat2 = rng.NextFloat(-5.0f, 5.0f); +} +``` \ No newline at end of file diff --git a/src/Documentation~/using-mathematics.md b/src/Documentation~/using-mathematics.md deleted file mode 100644 index 9637b93b..00000000 --- a/src/Documentation~/using-mathematics.md +++ /dev/null @@ -1,87 +0,0 @@ -# Using Unity Mathematics - -To use Unity Mathematics, add `using Unity.Mathematics` to your code: - -```C# -using static Unity.Mathematics.math; -namespace MyNamespace -{ - using Unity.Mathematics; - - ... - var v1 = float3(1,2,3); - var v2 = float3(4,5,6); - v1 = normalize(v1); - v2 = normalize(v2); - var v3 = dot(v1, v2); - ... -} -``` - -## Naming convention - -In C# `int` and `float` are built-in types. The Burst compiler extends this set of built-in types to also include vectors, matrices, and quaternions. These types are built-in because the Burst compiler already has implementations of these types, and so can use them to generate better code than for custom types. - -To signify that these types are built-in their type names are in all lower case. The operators on these built-in types in [`Unity.Mathematics.math`](xref:Unity.Mathematics.math) are intrinsics and are always in lower case. - -There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`). - -This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless. - - -## Vector multiplication - -To multiply vectors, use the `*`: - -```c# -// Unity Mathematics example -void ComponentwiseVectorMultiplyUnityMathematics() -{ - var v0 = new float4(2.0f, 4.0f, 6.0f, 8.0f); - var v1 = new float4(1.0f, -1.0f, 1.0f, -1.0f); - var result = v0 * v1; - // result == new float4(2.0f, -4.0f, 6.0f, -8.0f). -} -``` - -This is a common way of writing [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) code, which applies a single instruction to multiple data elements. Other operators such as addition, subtraction, and division work in the same way. - -## Quaternion multiplication - -To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors. - -```c# -// Unity Mathematics example -void QuaternionMultiplicationUnityMathematics() -{ - var axis = new float3(0.0f, 1.0f, 0.0f); - var q = quaternion.AxisAngle(axis,math.radians(45.0f)); - var orientation = quaternion.Euler( - math.radians(45.0f), - math.radians(90.0f), - math.radians(180.0f)); - var result = math.mul(q, orientation); -} -``` - -## Random numbers - -To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. - -Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive: - -```c# -// Unity Mathematics example -void RandomNumberUnityMathematics() -{ - // Choose some non-zero seed and set up the random number generator state. - uint seed = 1; - Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed); - - // [0, 1) exclusive - float randomFloat1 = rng.NextFloat(); - - // [-5, 5) exclusive - float randomFloat2 = rng.NextFloat(-5.0f, 5.0f); -} -``` \ No newline at end of file diff --git a/src/Documentation~/vector-multiplication.md b/src/Documentation~/vector-multiplication.md new file mode 100644 index 00000000..123fe6bb --- /dev/null +++ b/src/Documentation~/vector-multiplication.md @@ -0,0 +1,16 @@ +# Vector multiplication + +To multiply vectors, use the `*`: + +```c# +// Unity Mathematics example +void ComponentwiseVectorMultiplyUnityMathematics() +{ + var v0 = new float4(2.0f, 4.0f, 6.0f, 8.0f); + var v1 = new float4(1.0f, -1.0f, 1.0f, -1.0f); + var result = v0 * v1; + // result == new float4(2.0f, -4.0f, 6.0f, -8.0f). +} +``` + +This is a common way of writing [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) code, which applies a single instruction to multiple data elements. Other operators such as addition, subtraction, and division work in the same way. \ No newline at end of file From 7844450f9a08f160a9133f1d594fee8c32b1c7ec Mon Sep 17 00:00:00 2001 From: Jo Petty <49957016+jo-unity@users.noreply.github.com> Date: Mon, 4 Jul 2022 13:56:58 +0100 Subject: [PATCH 08/50] Update src/Documentation~/random-numbers.md Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com> --- src/Documentation~/random-numbers.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Documentation~/random-numbers.md b/src/Documentation~/random-numbers.md index 753108e3..7cd30394 100644 --- a/src/Documentation~/random-numbers.md +++ b/src/Documentation~/random-numbers.md @@ -2,7 +2,7 @@ To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. -Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive: +Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1)`, exclusive: ```c# // Unity Mathematics example From d41383b7335376333fb4b1ed91437b48601c7fc6 Mon Sep 17 00:00:00 2001 From: Jo Dawes Date: Mon, 4 Jul 2022 16:06:15 +0100 Subject: [PATCH 09/50] Updated docs based on feedback Changed compatibility page, and the random numbers page --- src/Documentation~/compatibility.md | 14 ++++++++------ src/Documentation~/random-numbers.md | 4 ++-- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/Documentation~/compatibility.md b/src/Documentation~/compatibility.md index 94d6f17c..5de185d1 100644 --- a/src/Documentation~/compatibility.md +++ b/src/Documentation~/compatibility.md @@ -1,15 +1,17 @@ -# Compatibility with `Mathf` +# Compatibility with `UnityEngine` mathematics -Unity Mathematics isn't implemented in the same way as the [`UnityEngine.Mathf`](https://docs.unity3d.com/ScriptReference/Mathf.html) struct in the core Unity engine. Because of this, if your application relies on the specific behaviors of `Mathf`, it might not be possible to use Unity Mathematics in your project. Also, if your project uses `Mathf` functions that have no corresponding Unity Mathematics function, or your code uses external plug-ins that depend on Unity types such as `Vector3`, or `Matrix4x4`, then you shouldn't use Unity Mathematics. +If you want to Burst-compile your project, it's best practice to use the Unity Mathematics package by default and only use `Mathf` when necessary. Unity Mathematics isn't implemented in the same way as the [`UnityEngine.Mathf`](https://docs.unity3d.com/ScriptReference/Mathf.html) struct in the core Unity engine. Because of this, if your application relies on the specific behaviors of `Mathf`, you'll have to reimplement them to get similar behavior in Unity Mathematics. >[!IMPORTANT] >For performance reasons, if your project uses the Mono compiler, you should continue to use the mathematical operations in `Mathf`, rather than Unity Mathematics. -## Porting `Mathf` code to Unity Mathematics +You can use both `Mathf` and Unity Mathematics methods in your project, but it might impact on the performance of your project because the conversions between the `UnityEngine` and `Unity.Mathematics` types such as `Vector3` to `float3` and vice-versa are performance-intensive. + +## Porting `UnityEngine` code to `Unity.Mathematics` If you want to migrate code from `UnityEngine` to `Unity.Mathematics`, you need to make the following changes first: -* `Vector4` to `float4` -* Multiplications on vector or matrix objects to component multiplication with the `*` operator. +* Update `UnityEngine` types to `Unity.Mathematics` types. For example, [`Vector4`](https://docs.unity3d.com/ScriptReference/Vector4.html) to [`float4`](xref:Unity.Mathematics.float4), and [`Quaternion`](https://docs.unity3d.com/ScriptReference/Quaternion.html) to [`quaternion`](xref:Unity.Mathematics.quaternion). These examples aren't exhaustive: see the [Scripting API reference](https://docs.unity3d.com/Packages/com.unity.mathematics@latest/index.html?subfolder=/api/index.html) for the full list of Unity Mathematics types available. +* Update any operators involved in matrices or vectors. For example, the `Matrix4x4` multiplication operator implements matrix multiplication, but the `float4x4` multiplication operator implements componentwise multiplication. * Degrees to radians -* How your code generates random numbers \ No newline at end of file +* How your code generates random numbers. `Random` in `Unity.Mathematics` works differently to [`Random`](https://docs.unity3d.com/ScriptReference/Random.html) in `UnityEngine`. You can completely control random number generation with `Random` in `Unity.Mathematics`, and it's instanced, rather than static. It's also exclusive with its upper bound, which is important to bear in mind if you want to convert `UnityEngine` code which is sensitive to the bounds. For more information, see the documentation on [Random numbers](random-numbers.md). diff --git a/src/Documentation~/random-numbers.md b/src/Documentation~/random-numbers.md index 7cd30394..5a09e9d9 100644 --- a/src/Documentation~/random-numbers.md +++ b/src/Documentation~/random-numbers.md @@ -1,6 +1,6 @@ ## Random numbers -To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. +To generate random numbers, you must create and manage the random number generator state yourself with the [`Random`](xref:Unity.Mathematics.Random) struct. You can control the random number generator state explicitly, which is useful if you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. You can also have as many `Random` instances as you like. Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1)`, exclusive: @@ -18,4 +18,4 @@ void RandomNumberUnityMathematics() // [-5, 5) exclusive float randomFloat2 = rng.NextFloat(-5.0f, 5.0f); } -``` \ No newline at end of file +``` From 27792767df03f4fc7b3d17a309079070c29696a7 Mon Sep 17 00:00:00 2001 From: Jo Dawes <49957016+jo-unity@users.noreply.github.com> Date: Mon, 4 Jul 2022 16:53:06 +0100 Subject: [PATCH 10/50] Update src/Documentation~/4x4-matrices.md Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com> --- src/Documentation~/4x4-matrices.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Documentation~/4x4-matrices.md b/src/Documentation~/4x4-matrices.md index 05f092b8..22c705e9 100644 --- a/src/Documentation~/4x4-matrices.md +++ b/src/Documentation~/4x4-matrices.md @@ -17,7 +17,7 @@ void Build4x4UnityMathematics() ## Multiplying a 4×4 matrix -Unity Mathematics defines the `*` operator differently to `UnityEngine`. The `*` operator for [`float4x4`](xref:Unity.Mathematics.float4x4) implements componentwise multiplication. If you multiply a `float4x4` of all 1s with 0.5 on the diagonal, you get back the half identity because the upper and lower triangles of the matrix are multiplied by the respective zero entries from `f4x4_HalfIdentity`: +Unity Mathematics and `UnityEngine` define the `*` operator differently. The `*` operator for [`float4x4`](xref:Unity.Mathematics.float4x4) implements componentwise multiplication. If you multiply a `float4x4` of all 1s with 0.5 on the diagonal, you get back the half identity because the upper and lower triangles of the matrix are multiplied by the respective zero entries from `f4x4_HalfIdentity`: ```c# // Unity Mathematics example From 75d8f4899319188323af729801712b274c2011c5 Mon Sep 17 00:00:00 2001 From: Jo Dawes <49957016+jo-unity@users.noreply.github.com> Date: Mon, 4 Jul 2022 16:53:34 +0100 Subject: [PATCH 11/50] Update src/Documentation~/4x4-matrices.md Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com> --- src/Documentation~/4x4-matrices.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Documentation~/4x4-matrices.md b/src/Documentation~/4x4-matrices.md index 22c705e9..266ec670 100644 --- a/src/Documentation~/4x4-matrices.md +++ b/src/Documentation~/4x4-matrices.md @@ -36,7 +36,7 @@ void OperatorMultiply4x4UnityMathematics() Use the [`math.mul`](xref:Unity.Mathematics.math.mul*) method to multiply a 4×4 matrix and a 4D vector. If you supply a `float4x4` as the first parameter and a `float4` as the second, it performs a 4×4 matrix multiplication with a 4×1 column vector, which returns a 4×1 column vector as a `float4`. -`math.mul` can also multiply a 1×4 row vector by a 4×4 matrix to produce a 1×4 row vector by taking a `float4` as the first parameter and a `float4×4` as the second. Unity Mathematics stores the row vector in a `float4` and it isn't treated as a separate type. +`math.mul` can also multiply a 1×4 row vector by a 4×4 matrix to produce a 1×4 row vector by taking a `float4` as the first parameter and a `float4×4` as the second. Unity Mathematics stores the row vector in a `float4` and it isn't treated as a separate type. ```c# // Unity Mathematics example From 0856b4fa49774557e8d99b181bbb643cca913f98 Mon Sep 17 00:00:00 2001 From: Jo Dawes <49957016+jo-unity@users.noreply.github.com> Date: Mon, 4 Jul 2022 16:59:49 +0100 Subject: [PATCH 12/50] Update src/Documentation~/compatibility.md Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com> --- src/Documentation~/compatibility.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Documentation~/compatibility.md b/src/Documentation~/compatibility.md index 5de185d1..9113e0a4 100644 --- a/src/Documentation~/compatibility.md +++ b/src/Documentation~/compatibility.md @@ -5,7 +5,7 @@ If you want to Burst-compile your project, it's best practice to use the Unity M >[!IMPORTANT] >For performance reasons, if your project uses the Mono compiler, you should continue to use the mathematical operations in `Mathf`, rather than Unity Mathematics. -You can use both `Mathf` and Unity Mathematics methods in your project, but it might impact on the performance of your project because the conversions between the `UnityEngine` and `Unity.Mathematics` types such as `Vector3` to `float3` and vice-versa are performance-intensive. +You can use both `Mathf` and Unity Mathematics methods in your project, but it might impact on the performance of your application because the conversions between the `UnityEngine` and `Unity.Mathematics` types such as `Vector3` to `float3` and vice-versa are performance-intensive. ## Porting `UnityEngine` code to `Unity.Mathematics` From 04fb13d15549a8e5b3db5ea6b788624e5a963f35 Mon Sep 17 00:00:00 2001 From: Jo Dawes <49957016+jo-unity@users.noreply.github.com> Date: Mon, 4 Jul 2022 17:02:11 +0100 Subject: [PATCH 13/50] Update src/Documentation~/quaternion-multiplication.md Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com> --- src/Documentation~/quaternion-multiplication.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Documentation~/quaternion-multiplication.md b/src/Documentation~/quaternion-multiplication.md index b9415b84..d6f70f4d 100644 --- a/src/Documentation~/quaternion-multiplication.md +++ b/src/Documentation~/quaternion-multiplication.md @@ -1,6 +1,6 @@ # Quaternion multiplication -To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors. +To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You need to specify the axis of rotation and the angle of rotation, in that order. All are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors. ```c# // Unity Mathematics example From 71e938fa6b9d05fce90ecac985786598f0efb65d Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Wed, 21 Sep 2022 17:16:25 -0700 Subject: [PATCH 14/50] Fix some doc errors. (#228) * Fix some doc errors. * Add nextpow2 to ceilpow2 documentation for searchability. * Add AffineTransform.zero. --- src/Tests/Tests/Shared/TestAffineTransform.cs | 7 +++++++ src/Unity.Mathematics/affine_transform.cs | 9 ++++++++- src/Unity.Mathematics/math.cs | 10 ++++++++++ 3 files changed, 25 insertions(+), 1 deletion(-) diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs index 460650cd..a5b31efe 100644 --- a/src/Tests/Tests/Shared/TestAffineTransform.cs +++ b/src/Tests/Tests/Shared/TestAffineTransform.cs @@ -162,5 +162,12 @@ public static void affine_transform_transform_point() float3 txPt0 = transform(tx, pt); TestUtils.AreEqual(mPt0, txPt0, 0.0001f); } + + [TestCompiler] + public static void affine_transform_zero() + { + TestUtils.AreEqual(float3x3.zero, AffineTransform.zero.rs); + TestUtils.AreEqual(float3.zero, AffineTransform.zero.t); + } } } \ No newline at end of file diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs index 33567b92..6ba30887 100644 --- a/src/Unity.Mathematics/affine_transform.cs +++ b/src/Unity.Mathematics/affine_transform.cs @@ -25,6 +25,11 @@ public struct AffineTransform : IEquatable, IFormattable /// An AffineTransform representing the identity transform. public static readonly AffineTransform identity = new AffineTransform(float3.zero, float3x3.identity); + /// + /// An AffineTransform zero value. + /// + public static readonly AffineTransform zero; + /// Constructs an AffineTransform from a translation represented by a float3 vector and rotation represented by a unit quaternion. /// The translation vector. /// The rotation quaternion. @@ -94,11 +99,13 @@ public AffineTransform(float4x4 m) /// Implicit float3x4 cast operator. /// The AffineTransform. + /// The converted AffineTransform. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator float3x4(AffineTransform m) { return float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); } /// Implicit float4x4 cast operator. /// The AffineTransform. + /// The converted AffineTransform. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator float4x4(AffineTransform m) { return float4x4(float4(m.rs.c0, 0f), float4(m.rs.c1, 0f), float4(m.rs.c2, 0f), float4(m.t, 1f)); } @@ -265,7 +272,7 @@ public static float3 transform(AffineTransform a, float3 pos) } /// Returns the inverse of an AffineTransform. - /// The AffineTransform to invert. + /// The AffineTransform to invert. /// The inverse AffineTransform. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static AffineTransform inverse(AffineTransform a) diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs index f2ef33b7..26b0d378 100644 --- a/src/Unity.Mathematics/math.cs +++ b/src/Unity.Mathematics/math.cs @@ -5514,6 +5514,7 @@ public static ulong reversebits(ulong x) /// Returns the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5529,6 +5530,7 @@ public static int ceilpow2(int x) } /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The componentwise smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5544,6 +5546,7 @@ public static int2 ceilpow2(int2 x) } /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The componentwise smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5559,6 +5562,7 @@ public static int3 ceilpow2(int3 x) } /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The componentwise smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5575,6 +5579,7 @@ public static int4 ceilpow2(int4 x) /// Returns the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5590,6 +5595,7 @@ public static uint ceilpow2(uint x) } /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The componentwise smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5605,6 +5611,7 @@ public static uint2 ceilpow2(uint2 x) } /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The componentwise smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5620,6 +5627,7 @@ public static uint3 ceilpow2(uint3 x) } /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The componentwise smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5636,6 +5644,7 @@ public static uint4 ceilpow2(uint4 x) /// Returns the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -5653,6 +5662,7 @@ public static long ceilpow2(long x) /// Returns the smallest power of two greater than or equal to the input. + /// Also known as nextpow2. /// Input value. /// The smallest power of two greater than or equal to the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] From df595bb0736b1b767984f8510214821a49fa54ca Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Mon, 26 Sep 2022 18:27:50 -0700 Subject: [PATCH 15/50] Fix solution to refer to renamed code gen project. (#227) --- src/Unity.Mathematics.sln | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln index 19d5c88a..7651ca6e 100644 --- a/src/Unity.Mathematics.sln +++ b/src/Unity.Mathematics.sln @@ -5,8 +5,6 @@ VisualStudioVersion = 16.0.29806.167 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics", "Unity.Mathematics\Unity.Mathematics.csproj", "{19810344-7387-4155-935F-BDD5CC61F0BF}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics.CodeGen", "Unity.Mathematics.CodeGen\Unity.Mathematics.CodeGen.csproj", "{293EBCD6-CACD-4DA8-A518-FBC629268C0F}" -EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "General", "General", "{B11ECCE1-1A78-40B2-956F-CBE615FF5DF9}" ProjectSection(SolutionItems) = preProject CHANGELOG.md = CHANGELOG.md @@ -16,6 +14,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "General", "General", "{B11E EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics.Tests", "Tests\Unity.Mathematics.Tests.csproj", "{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics.CodeGen", "Unity.Mathematics.CodeGen~\Unity.Mathematics.CodeGen.csproj", "{293EBCD6-CACD-4DA8-A518-FBC629268C0F}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -38,18 +38,6 @@ Global {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.Build.0 = Release|x64 {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.ActiveCfg = Release|Any CPU {19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.Build.0 = Release|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.ActiveCfg = Debug|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.Build.0 = Debug|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.ActiveCfg = Debug|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.Build.0 = Debug|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.Build.0 = Release|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.ActiveCfg = Release|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.Build.0 = Release|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.ActiveCfg = Release|Any CPU - {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.Build.0 = Release|Any CPU {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Debug|Any CPU.Build.0 = Debug|Any CPU {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Debug|x64.ActiveCfg = Debug|Any CPU From 91445d8576f9313bc4b74e86b4e6adb0b62edca9 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Wed, 28 Sep 2022 14:11:38 -0700 Subject: [PATCH 16/50] Add configurations to build. (#230) --- src/Unity.Mathematics.sln | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln index 7651ca6e..a0ea6974 100644 --- a/src/Unity.Mathematics.sln +++ b/src/Unity.Mathematics.sln @@ -50,6 +50,10 @@ Global {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x64.Build.0 = Release|Any CPU {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x86.ActiveCfg = Release|Any CPU {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x86.Build.0 = Release|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE From f1a296b9ed3021b980abb69d2a66d20fe1453d5e Mon Sep 17 00:00:00 2001 From: kevinmv <45053404+kevinmv@users.noreply.github.com> Date: Thu, 27 Apr 2023 19:37:14 -0400 Subject: [PATCH 17/50] Update License to 2023 --- LICENSE.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LICENSE.md b/LICENSE.md index a95cdfbe..0c7f3fac 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,4 +1,4 @@ -com.unity.mathematics copyright © 2022 Unity Technologies ApS +com.unity.mathematics copyright © 2023 Unity Technologies ApS Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license). -Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions. \ No newline at end of file +Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions. From c8d9473ead179d0d49d72147825256e5f7cf5228 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Thu, 27 Apr 2023 17:02:09 -0700 Subject: [PATCH 18/50] Update package copy of license file. Probably should figure out which one of these is the authoritative one... --- src/LICENSE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/LICENSE.md b/src/LICENSE.md index a95cdfbe..1f5c0f44 100755 --- a/src/LICENSE.md +++ b/src/LICENSE.md @@ -1,4 +1,4 @@ -com.unity.mathematics copyright © 2022 Unity Technologies ApS +com.unity.mathematics copyright © 2023 Unity Technologies ApS Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license). Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions. \ No newline at end of file From 29a4f3fb3c0f2fc5f3920aebb69e27b277847c3d Mon Sep 17 00:00:00 2001 From: Peter Lu Date: Mon, 5 Jun 2023 15:07:38 -0400 Subject: [PATCH 19/50] -Updated upm-ci.yml by removing the 2020.3/partner/staging branch -Added LTS branches for 2021 and 2022 -Added 2023.1 version --- .yamato/upm-ci.yml | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml index 7abddb97..cbde2bd8 100644 --- a/.yamato/upm-ci.yml +++ b/.yamato/upm-ci.yml @@ -33,14 +33,12 @@ validate_editor_versions: display_name: "2019.4" - version: "2020.3" display_name: "2020.3" - - version: "2021.1" - display_name: "2021.1" - - version: "2021.2" - display_name: "2021.2" - - version: "2022.1" - display_name: "2022.1" - - version: "2020.3/partner/staging" - display_name: "2020.3_partner_staging" + - version: "2021.3" + display_name: "2021.3" + - version: "2022.3" + display_name: "2022.3" + - version: "2023.1" + display_name: "2023.1" - version: "trunk" display_name: "trunk" @@ -56,14 +54,12 @@ package_tests_editor_versions: display_name: "2019.4" - version: "2020.3" display_name: "2020.3" - - version: "2021.1" - display_name: "2021.1" - - version: "2021.2" - display_name: "2021.2" - - version: "2022.1" - display_name: "2022.1" - - version: "2020.3/partner/staging" - display_name: "2020.3_partner_staging" + - version: "2021.3" + display_name: "2021.3" + - version: "2022.3" + display_name: "2022.3" + - version: "2023.1" + display_name: "2023.1" - version: "trunk" display_name: "trunk" --- From 76466c7fbbdcad835c25cd31c7c20a5faccd6db5 Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Wed, 12 Jul 2023 13:24:23 -0700 Subject: [PATCH 20/50] update changelog and version --- src/CHANGELOG.md | 35 +++++++++++++++++++---------------- src/package.json | 2 +- 2 files changed, 20 insertions(+), 17 deletions(-) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 7e856def..4a2f3065 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -1,6 +1,15 @@ # Changelog ## [Unreleased] +### Added +### Changed +### Deprecated +### Removed +### Fixed + + +## [1.3.0] 2023-07-12 + ### Added * Added `math.square` to compute the square (x * x). * Added `math.orthonormal_basis` to compute an orthonormal basis from a single unit length vector. @@ -13,31 +22,32 @@ * Added `math.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3. * Added `AffineTransform` type. * Added `PI2`, `PIHALF`, `TAU`, `TODEGREES` and `TORADIANS` constants. + ### Changed * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement. * Modified `quaternion.nlerp` to be branchless. * More descriptive parameter names for many methods in `math` class. * Made `Il2CppEagerStaticClassConstructionAttribute` internal to avoid conflicts with other definitions outside of the package. -### Deprecated -### Removed -### Fixed -## [1.2.5] - 2021-11-01 -### Added +## [1.2.6] - 2022-02-11 + ### Changed -### Deprecated -### Removed +* Made Il2CppEagerStaticClassConstructionAttribute internal to avoid conflicts with other definitions outside of the package. + +## [1.2.5] - 2021-11-01 + ### Fixed * Fixed property drawing when manually drawing a property that was hidden with [HideInInspector]. ## [1.2.4] - 2021-09-22 + ### Added * Added `[Il2CppEagerStaticClassConstruction]` to Unity.Mathematics types to run static constructors at startup. This improves IL2CPP performance slightly for types that have static constructors. + ### Changed * License file updated to satisfy Unity's package validation tests. * Changed noise documentation in comments to xmldoc comments. -### Deprecated -### Removed + ### Fixed * Fixed Equals(object) override which did not check type before casting. This could cause exceptions to be thrown when the object did not match the expected type. * Fixed incorrect `math.tzcnt` documentation which mentioned leading zero counts instead of trailing zero counts. @@ -46,10 +56,6 @@ ## [1.2.1] - 2020-08-06 -### Added -### Changed -### Deprecated -### Removed ### Fixed * Fixed warnings for meta files existing even though the files they represent did not exist. @@ -73,9 +79,6 @@ * Added some performance tests which can be run from the Unity test project. * Added `Random.CreateFromIndex()` to assist in creating Random instances from loop indices. -### Changed -### Deprecated -### Removed ### Fixed * Fixed documentation bug where `quaternion.RotateX/Y/Z` referred to a `float4x4` instead of quaternion. * Fixed code generation bugs which could cause Windows and Mac to generate different test code. diff --git a/src/package.json b/src/package.json index f99d7f78..65b75fc8 100755 --- a/src/package.json +++ b/src/package.json @@ -1,7 +1,7 @@ { "name": "com.unity.mathematics", "displayName": "Mathematics", - "version": "1.2.5", + "version": "1.3.0", "unity": "2018.3", "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.", "keywords": [ From 97c192a7ae15d3b01b48b4c8104339b57a8c8578 Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Thu, 27 Jul 2023 14:32:15 -0700 Subject: [PATCH 21/50] minor changelog fix Sorry. --- src/CHANGELOG.md | 2 +- src/package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 4a2f3065..0ee687ff 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -8,7 +8,7 @@ ### Fixed -## [1.3.0] 2023-07-12 +## [1.3.1] - 2023-07-12 ### Added * Added `math.square` to compute the square (x * x). diff --git a/src/package.json b/src/package.json index 65b75fc8..5e0509b2 100755 --- a/src/package.json +++ b/src/package.json @@ -1,7 +1,7 @@ { "name": "com.unity.mathematics", "displayName": "Mathematics", - "version": "1.3.0", + "version": "1.3.1", "unity": "2018.3", "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.", "keywords": [ From 8a6d6fc400f396fc7be22fcf5bcae4721cb6fb4a Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Mon, 21 Aug 2023 19:03:04 -0700 Subject: [PATCH 22/50] ECSB-529 ECSB-506 Fix arm hash crash (#241) Fix `math.hash` crash with arm 32 bit il2cpp builds. --- .yamato/upm-ci.yml | 21 +- .../Assets/Scenes/SampleScene.unity | 133 ++- .../Scenes/SampleSceneSettings.lighting | 66 ++ .../Scenes/SampleSceneSettings.lighting.meta | 8 + .../Packages/manifest.json | 12 +- .../ProjectSettings/EditorBuildSettings.asset | 5 +- .../ProjectSettings/GraphicsSettings.asset | 4 + .../ProjectSettings/ProjectSettings.asset | 303 +++++-- .../ProjectSettings/ProjectVersion.txt | 4 +- .../UnityConnectSettings.asset | 2 + src/CHANGELOG.md | 2 +- src/Tests/Tests/Shared/TestAffineTransform.cs | 26 +- src/Tests/Tests/Shared/TestBitmanipulation.cs | 122 +-- src/Tests/Tests/Shared/TestBool2.gen.cs | 42 +- src/Tests/Tests/Shared/TestBool2x2.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool2x3.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool2x4.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool3.gen.cs | 42 +- src/Tests/Tests/Shared/TestBool3x2.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool3x3.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool3x4.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool4.gen.cs | 42 +- src/Tests/Tests/Shared/TestBool4x2.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool4x3.gen.cs | 34 +- src/Tests/Tests/Shared/TestBool4x4.gen.cs | 34 +- src/Tests/Tests/Shared/TestDouble2.gen.cs | 98 +-- src/Tests/Tests/Shared/TestDouble2x2.gen.cs | 84 +- src/Tests/Tests/Shared/TestDouble2x3.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble2x4.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble3.gen.cs | 98 +-- src/Tests/Tests/Shared/TestDouble3x2.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble3x3.gen.cs | 84 +- src/Tests/Tests/Shared/TestDouble3x4.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble4.gen.cs | 98 +-- src/Tests/Tests/Shared/TestDouble4x2.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble4x3.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble4x4.gen.cs | 84 +- src/Tests/Tests/Shared/TestFloat2.gen.cs | 98 +-- src/Tests/Tests/Shared/TestFloat2x2.gen.cs | 84 +- src/Tests/Tests/Shared/TestFloat2x3.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat2x4.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat3.gen.cs | 98 +-- src/Tests/Tests/Shared/TestFloat3x2.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat3x3.gen.cs | 84 +- src/Tests/Tests/Shared/TestFloat3x4.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat4.gen.cs | 98 +-- src/Tests/Tests/Shared/TestFloat4x2.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat4x3.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat4x4.gen.cs | 84 +- src/Tests/Tests/Shared/TestHalf.cs | 90 +- src/Tests/Tests/Shared/TestInt2.gen.cs | 122 +-- src/Tests/Tests/Shared/TestInt2x2.gen.cs | 108 +-- src/Tests/Tests/Shared/TestInt2x3.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt2x4.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt3.gen.cs | 122 +-- src/Tests/Tests/Shared/TestInt3x2.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt3x3.gen.cs | 108 +-- src/Tests/Tests/Shared/TestInt3x4.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt4.gen.cs | 122 +-- src/Tests/Tests/Shared/TestInt4x2.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt4x3.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt4x4.gen.cs | 108 +-- src/Tests/Tests/Shared/TestMath.cs | 568 ++++++------ src/Tests/Tests/Shared/TestMath.gen.cs | 820 +++++++++--------- src/Tests/Tests/Shared/TestMatrix.cs | 122 +-- src/Tests/Tests/Shared/TestMinMaxAABB.cs | 90 +- src/Tests/Tests/Shared/TestPlane.cs | 44 +- src/Tests/Tests/Shared/TestQuaternion.cs | 56 +- src/Tests/Tests/Shared/TestRigidTransform.cs | 16 +- src/Tests/Tests/Shared/TestSvd.cs | 16 +- src/Tests/Tests/Shared/TestUint2.gen.cs | 122 +-- src/Tests/Tests/Shared/TestUint2x2.gen.cs | 108 +-- src/Tests/Tests/Shared/TestUint2x3.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint2x4.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint3.gen.cs | 122 +-- src/Tests/Tests/Shared/TestUint3x2.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint3x3.gen.cs | 108 +-- src/Tests/Tests/Shared/TestUint3x4.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint4.gen.cs | 122 +-- src/Tests/Tests/Shared/TestUint4x2.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint4x3.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint4x4.gen.cs | 108 +-- src/Tests/Tests/TestMath2.cs | 69 +- src/Tests/Tests/TestRandom.cs | 232 ++--- src/Tests/Unity.Mathematics.Tests.asmdef | 24 +- .../VectorGenerator.cs | 4 +- .../TestHash.cs | 58 ++ .../TestHash.cs.meta | 11 + src/Unity.Mathematics.sln | 8 + src/Unity.Mathematics/math.cs | 87 +- 90 files changed, 4366 insertions(+), 3817 deletions(-) create mode 100644 Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting create mode 100644 Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta create mode 100644 src/Unity.Mathematics.PerformanceTests/TestHash.cs create mode 100644 src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml index cbde2bd8..2a554b38 100644 --- a/.yamato/upm-ci.yml +++ b/.yamato/upm-ci.yml @@ -27,12 +27,6 @@ upmci_platforms: flavor: b1.large validate_editor_versions: - - version: "2018.4" - display_name: "2018.4" - - version: "2019.4" - display_name: "2019.4" - - version: "2020.3" - display_name: "2020.3" - version: "2021.3" display_name: "2021.3" - version: "2022.3" @@ -43,17 +37,6 @@ validate_editor_versions: display_name: "trunk" package_tests_editor_versions: - # 2018.3 shows up here but not under validate_editor_versions because package validation is no longer - # supported on 2018.3 but Mathematics still supports it so we need to be able to test it. CI jobs - # from this list will run package tests only instead of the full validation suite. - - version: "2018.3" - display_name: "2018.3" - - version: "2018.4" - display_name: "2018.4" - - version: "2019.4" - display_name: "2019.4" - - version: "2020.3" - display_name: "2020.3" - version: "2021.3" display_name: "2021.3" - version: "2022.3" @@ -96,7 +79,7 @@ package_tests_minimal: name: Package tests minimal dependencies: {% for platform in upmci_platforms %} - - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2018.3 + - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2021.3 {% endfor %} validate_package_minimal: @@ -108,7 +91,7 @@ validate_package_minimal: commands: - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g - upm-ci package pack --package-path src/ - - upm-ci package test --package-path src/ --unity-version 2019.4 + - upm-ci package test --package-path src/ --unity-version 2021.3 artifacts: packages: paths: diff --git a/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity b/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity index 7cdec2a0..b819a102 100644 --- a/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity +++ b/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity @@ -38,24 +38,23 @@ RenderSettings: m_ReflectionIntensity: 1 m_CustomReflection: {fileID: 0} m_Sun: {fileID: 705507994} - m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1} + m_IndirectSpecularColor: {r: 0.44402242, g: 0.49316543, b: 0.5722324, a: 1} m_UseRadianceAmbientProbe: 0 --- !u!157 &3 LightmapSettings: m_ObjectHideFlags: 0 - serializedVersion: 11 + serializedVersion: 12 m_GIWorkflowMode: 0 m_GISettings: serializedVersion: 2 m_BounceScale: 1 m_IndirectOutputScale: 1 m_AlbedoBoost: 1 - m_TemporalCoherenceThreshold: 1 m_EnvironmentLightingMode: 0 m_EnableBakedLightmaps: 1 m_EnableRealtimeLightmaps: 1 m_LightmapEditorSettings: - serializedVersion: 10 + serializedVersion: 12 m_Resolution: 2 m_BakeResolution: 40 m_AtlasSize: 1024 @@ -63,6 +62,7 @@ LightmapSettings: m_AOMaxDistance: 1 m_CompAOExponent: 1 m_CompAOExponentDirect: 0 + m_ExtractAmbientOcclusion: 0 m_Padding: 2 m_LightmapParameters: {fileID: 0} m_LightmapsBakeMode: 1 @@ -77,10 +77,16 @@ LightmapSettings: m_PVRDirectSampleCount: 32 m_PVRSampleCount: 500 m_PVRBounces: 2 + m_PVREnvironmentSampleCount: 500 + m_PVREnvironmentReferencePointCount: 2048 + m_PVRFilteringMode: 2 + m_PVRDenoiserTypeDirect: 0 + m_PVRDenoiserTypeIndirect: 0 + m_PVRDenoiserTypeAO: 0 m_PVRFilterTypeDirect: 0 m_PVRFilterTypeIndirect: 0 m_PVRFilterTypeAO: 0 - m_PVRFilteringMode: 1 + m_PVREnvironmentMIS: 0 m_PVRCulling: 1 m_PVRFilteringGaussRadiusDirect: 1 m_PVRFilteringGaussRadiusIndirect: 5 @@ -88,15 +94,18 @@ LightmapSettings: m_PVRFilteringAtrousPositionSigmaDirect: 0.5 m_PVRFilteringAtrousPositionSigmaIndirect: 2 m_PVRFilteringAtrousPositionSigmaAO: 1 - m_ShowResolutionOverlay: 1 + m_ExportTrainingData: 0 + m_TrainingDataDestination: TrainingData + m_LightProbeSampleCountMultiplier: 4 m_LightingDataAsset: {fileID: 0} - m_UseShadowmask: 1 + m_LightingSettings: {fileID: 4890085278179872738, guid: 20c8488ac153b4f45944c2d7c85a094e, + type: 2} --- !u!196 &4 NavMeshSettings: serializedVersion: 2 m_ObjectHideFlags: 0 m_BuildSettings: - serializedVersion: 2 + serializedVersion: 3 agentTypeID: 0 agentRadius: 0.5 agentHeight: 2 @@ -109,15 +118,49 @@ NavMeshSettings: cellSize: 0.16666667 manualTileSize: 0 tileSize: 256 - accuratePlacement: 0 + buildHeightMesh: 0 + maxJobWorkers: 0 + preserveTilesOutsideBounds: 0 debug: m_Flags: 0 m_NavMeshData: {fileID: 0} +--- !u!1 &206998647 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 206998649} + m_Layer: 0 + m_Name: GameObject + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &206998649 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 206998647} + serializedVersion: 2 + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 0} + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &705507993 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 705507995} @@ -133,15 +176,18 @@ GameObject: Light: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 705507993} m_Enabled: 1 - serializedVersion: 8 + serializedVersion: 10 m_Type: 1 + m_Shape: 0 m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1} m_Intensity: 1 m_Range: 10 m_SpotAngle: 30 + m_InnerSpotAngle: 21.80208 m_CookieSize: 10 m_Shadows: m_Type: 2 @@ -151,6 +197,24 @@ Light: m_Bias: 0.05 m_NormalBias: 0.4 m_NearPlane: 0.2 + m_CullingMatrixOverride: + e00: 1 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 1 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 1 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 1 + m_UseCullingMatrixOverride: 0 m_Cookie: {fileID: 0} m_DrawHalo: 0 m_Flare: {fileID: 0} @@ -158,32 +222,39 @@ Light: m_CullingMask: serializedVersion: 2 m_Bits: 4294967295 + m_RenderingLayerMask: 1 m_Lightmapping: 1 m_LightShadowCasterMode: 0 m_AreaSize: {x: 1, y: 1} m_BounceIntensity: 1 m_ColorTemperature: 6570 m_UseColorTemperature: 0 + m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0} + m_UseBoundingSphereOverride: 0 + m_UseViewFrustumForShadowCasterCull: 1 m_ShadowRadius: 0 m_ShadowAngle: 0 --- !u!4 &705507995 Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 705507993} + serializedVersion: 2 m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261} m_LocalPosition: {x: 0, y: 3, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 0} - m_RootOrder: 1 m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0} --- !u!1 &963194225 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 963194228} @@ -200,24 +271,35 @@ GameObject: AudioListener: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 963194225} m_Enabled: 1 --- !u!20 &963194227 Camera: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 963194225} m_Enabled: 1 serializedVersion: 2 m_ClearFlags: 1 m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} m_projectionMatrixMode: 1 - m_SensorSize: {x: 36, y: 24} - m_LensShift: {x: 0, y: 0} m_GateFitMode: 2 + m_FOVAxisMode: 0 + m_Iso: 200 + m_ShutterSpeed: 0.005 + m_Aperture: 16 + m_FocusDistance: 10 m_FocalLength: 50 + m_BladeCount: 5 + m_Curvature: {x: 2, y: 11} + m_BarrelClipping: 0.25 + m_Anamorphism: 0 + m_SensorSize: {x: 36, y: 24} + m_LensShift: {x: 0, y: 0} m_NormalizedViewPortRect: serializedVersion: 2 x: 0 @@ -248,12 +330,21 @@ Camera: Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 963194225} + serializedVersion: 2 m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 1, z: -10} m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 0} - m_RootOrder: 0 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1660057539 &9223372036854775807 +SceneRoots: + m_ObjectHideFlags: 0 + m_Roots: + - {fileID: 963194228} + - {fileID: 705507995} + - {fileID: 206998649} diff --git a/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting new file mode 100644 index 00000000..e595ed65 --- /dev/null +++ b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting @@ -0,0 +1,66 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!850595691 &4890085278179872738 +LightingSettings: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: SampleSceneSettings + serializedVersion: 6 + m_GIWorkflowMode: 0 + m_EnableBakedLightmaps: 1 + m_EnableRealtimeLightmaps: 1 + m_RealtimeEnvironmentLighting: 1 + m_BounceScale: 1 + m_AlbedoBoost: 1 + m_IndirectOutputScale: 1 + m_UsingShadowmask: 1 + m_BakeBackend: 1 + m_LightmapMaxSize: 1024 + m_BakeResolution: 40 + m_Padding: 2 + m_LightmapCompression: 3 + m_AO: 0 + m_AOMaxDistance: 1 + m_CompAOExponent: 1 + m_CompAOExponentDirect: 0 + m_ExtractAO: 0 + m_MixedBakeMode: 2 + m_LightmapsBakeMode: 1 + m_FilterMode: 1 + m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0} + m_ExportTrainingData: 0 + m_TrainingDataDestination: TrainingData + m_RealtimeResolution: 2 + m_ForceWhiteAlbedo: 0 + m_ForceUpdates: 0 + m_FinalGather: 0 + m_FinalGatherRayCount: 256 + m_FinalGatherFiltering: 1 + m_PVRCulling: 1 + m_PVRSampling: 1 + m_PVRDirectSampleCount: 32 + m_PVRSampleCount: 512 + m_PVREnvironmentSampleCount: 512 + m_PVREnvironmentReferencePointCount: 2048 + m_LightProbeSampleCountMultiplier: 4 + m_PVRBounces: 2 + m_PVRMinBounces: 2 + m_PVREnvironmentImportanceSampling: 0 + m_PVRFilteringMode: 2 + m_PVRDenoiserTypeDirect: 0 + m_PVRDenoiserTypeIndirect: 0 + m_PVRDenoiserTypeAO: 0 + m_PVRFilterTypeDirect: 0 + m_PVRFilterTypeIndirect: 0 + m_PVRFilterTypeAO: 0 + m_PVRFilteringGaussRadiusDirect: 1 + m_PVRFilteringGaussRadiusIndirect: 5 + m_PVRFilteringGaussRadiusAO: 2 + m_PVRFilteringAtrousPositionSigmaDirect: 0.5 + m_PVRFilteringAtrousPositionSigmaIndirect: 2 + m_PVRFilteringAtrousPositionSigmaAO: 1 + m_PVRTiledBaking: 0 + m_NumRaysToShootPerTexel: -1 + m_RespectSceneVisibilityWhenBakingGI: 0 diff --git a/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta new file mode 100644 index 00000000..daa2a351 --- /dev/null +++ b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 20c8488ac153b4f45944c2d7c85a094e +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 4890085278179872738 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Unity.Mathematics.TestProject/Packages/manifest.json b/Unity.Mathematics.TestProject/Packages/manifest.json index 5b27463f..e40c4a4b 100644 --- a/Unity.Mathematics.TestProject/Packages/manifest.json +++ b/Unity.Mathematics.TestProject/Packages/manifest.json @@ -1,12 +1,14 @@ { "dependencies": { - "com.unity.burst": "1.2.3", - "com.unity.ide.rider": "1.1.4", - "com.unity.ide.vscode": "1.1.4", + "com.unity.ai.navigation": "1.1.4", + "com.unity.burst": "1.8.7", + "com.unity.ide.rider": "3.0.24", + "com.unity.ide.visualstudio": "2.0.18", + "com.unity.ide.vscode": "1.2.5", "com.unity.mathematics": "file:../../src", "com.unity.package-validation-suite": "0.8.1-preview", - "com.unity.properties": "0.10.4-preview", - "com.unity.test-framework": "1.1.11", + "com.unity.properties": "2.1.0-exp.3", + "com.unity.test-framework": "1.1.33", "com.unity.test-framework.performance": "2.8.0-preview" }, "testables": [ diff --git a/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset index 0147887e..40917b05 100644 --- a/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset +++ b/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset @@ -4,5 +4,8 @@ EditorBuildSettings: m_ObjectHideFlags: 0 serializedVersion: 2 - m_Scenes: [] + m_Scenes: + - enabled: 1 + path: Assets/Scenes/SampleScene.unity + guid: 9fc0d4010bbf28b4594072e72b8655ab m_configObjects: {} diff --git a/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset index 35a0fa7f..bea55798 100644 --- a/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset +++ b/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset @@ -36,6 +36,10 @@ GraphicsSettings: - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 10783, guid: 0000000000000000f000000000000000, type: 0} + - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0} + - {fileID: 16001, guid: 0000000000000000f000000000000000, type: 0} + - {fileID: 16003, guid: 0000000000000000f000000000000000, type: 0} + - {fileID: 17000, guid: 0000000000000000f000000000000000, type: 0} m_PreloadedShaders: [] m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0} diff --git a/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset index f8345c9f..9eb3e0b5 100644 --- a/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset +++ b/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset @@ -3,7 +3,7 @@ --- !u!129 &1 PlayerSettings: m_ObjectHideFlags: 0 - serializedVersion: 20 + serializedVersion: 26 productGUID: 50c0163089a174a7ab9f46f0020a809f AndroidProfiler: 0 AndroidFilterTouchesWhenObscured: 0 @@ -48,12 +48,15 @@ PlayerSettings: defaultScreenHeightWeb: 600 m_StereoRenderingPath: 0 m_ActiveColorSpace: 0 + m_SpriteBatchVertexThreshold: 300 m_MTRendering: 1 + mipStripping: 0 + numberOfMipsStripped: 0 + numberOfMipsStrippedPerMipmapLimitGroup: {} m_StackTraceTypes: 010000000100000001000000010000000100000001000000 iosShowActivityIndicatorOnLoading: -1 androidShowActivityIndicatorOnLoading: -1 iosUseCustomAppBackgroundBehavior: 0 - iosAllowHTTPDownload: 1 allowedAutorotateToPortrait: 1 allowedAutorotateToPortraitUpsideDown: 1 allowedAutorotateToLandscapeRight: 1 @@ -66,6 +69,12 @@ PlayerSettings: androidRenderOutsideSafeArea: 1 androidUseSwappy: 0 androidBlitType: 0 + androidResizableWindow: 0 + androidDefaultWindowWidth: 1920 + androidDefaultWindowHeight: 1080 + androidMinimumWindowWidth: 400 + androidMinimumWindowHeight: 300 + androidFullscreenMode: 1 defaultIsNativeResolution: 1 macRetinaSupport: 1 runInBackground: 1 @@ -103,6 +112,7 @@ PlayerSettings: xboxOneMonoLoggingLevel: 0 xboxOneLoggingLevel: 1 xboxOneDisableEsram: 0 + xboxOneEnableTypeOptimization: 0 xboxOnePresentImmediateThreshold: 0 switchQueueCommandMemory: 0 switchQueueControlMemory: 16384 @@ -110,14 +120,19 @@ PlayerSettings: switchNVNShaderPoolsGranularity: 33554432 switchNVNDefaultPoolsGranularity: 16777216 switchNVNOtherPoolsGranularity: 16777216 + switchGpuScratchPoolGranularity: 2097152 + switchAllowGpuScratchShrinking: 0 + switchNVNMaxPublicTextureIDCount: 0 + switchNVNMaxPublicSamplerIDCount: 0 + switchNVNGraphicsFirmwareMemory: 32 + stadiaPresentMode: 0 + stadiaTargetFramerate: 0 vulkanNumSwapchainBuffers: 3 vulkanEnableSetSRGBWrite: 0 - m_SupportedAspectRatios: - 4:3: 1 - 5:4: 1 - 16:10: 1 - 16:9: 1 - Others: 1 + vulkanEnablePreTransform: 0 + vulkanEnableLateAcquireNextImage: 0 + vulkanEnableCommandBufferRecycling: 1 + loadStoreDebugModeEnabled: 0 bundleVersion: 0.1 preloadedAssets: [] metroInputSource: 0 @@ -126,45 +141,28 @@ PlayerSettings: xboxOneDisableKinectGpuReservation: 0 xboxOneEnable7thCore: 0 vrSettings: - cardboard: - depthFormat: 0 - enableTransitionView: 0 - daydream: - depthFormat: 0 - useSustainedPerformanceMode: 0 - enableVideoLayer: 0 - useProtectedVideoMemory: 0 - minimumSupportedHeadTracking: 0 - maximumSupportedHeadTracking: 1 - hololens: - depthFormat: 1 - depthBufferSharingEnabled: 0 - lumin: - depthFormat: 0 - frameTiming: 2 - enableGLCache: 0 - glCacheMaxBlobSize: 524288 - glCacheMaxFileSize: 8388608 - oculus: - sharedDepthBuffer: 1 - dashSupport: 1 - lowOverheadMode: 0 - protectedContext: 0 - v2Signing: 1 enable360StereoCapture: 0 isWsaHolographicRemotingEnabled: 0 enableFrameTimingStats: 0 + enableOpenGLProfilerGPURecorders: 1 useHDRDisplay: 0 - D3DHDRBitDepth: 0 + hdrBitDepth: 0 m_ColorGamuts: 00000000 targetPixelDensity: 30 resolutionScalingMode: 0 + resetResolutionOnWindowResize: 0 androidSupportedAspectRatio: 1 androidMaxAspectRatio: 2.1 - applicationIdentifier: {} - buildNumber: {} + applicationIdentifier: + Android: com.UnityTestRunner.UnityTestRunner + buildNumber: + Standalone: 0 + VisionOS: 0 + iPhone: 0 + tvOS: 0 + overrideDefaultApplicationIdentifier: 1 AndroidBundleVersionCode: 1 - AndroidMinSdkVersion: 19 + AndroidMinSdkVersion: 22 AndroidTargetSdkVersion: 0 AndroidPreferredInstallLocation: 1 aotOptions: @@ -177,34 +175,21 @@ PlayerSettings: APKExpansionFiles: 0 keepLoadedShadersAlive: 0 StripUnusedMeshComponents: 1 + strictShaderVariantMatching: 0 VertexChannelCompressionMask: 4054 iPhoneSdkVersion: 988 - iOSTargetOSVersionString: 10.0 + iOSTargetOSVersionString: 12.0 tvOSSdkVersion: 0 tvOSRequireExtendedGameController: 0 - tvOSTargetOSVersionString: 10.0 + tvOSTargetOSVersionString: 12.0 + VisionOSSdkVersion: 0 + VisionOSTargetOSVersionString: 1.0 uIPrerenderedIcon: 0 uIRequiresPersistentWiFi: 0 uIRequiresFullScreen: 1 uIStatusBarHidden: 1 uIExitOnSuspend: 0 uIStatusBarStyle: 0 - iPhoneSplashScreen: {fileID: 0} - iPhoneHighResSplashScreen: {fileID: 0} - iPhoneTallHighResSplashScreen: {fileID: 0} - iPhone47inSplashScreen: {fileID: 0} - iPhone55inPortraitSplashScreen: {fileID: 0} - iPhone55inLandscapeSplashScreen: {fileID: 0} - iPhone58inPortraitSplashScreen: {fileID: 0} - iPhone58inLandscapeSplashScreen: {fileID: 0} - iPadPortraitSplashScreen: {fileID: 0} - iPadHighResPortraitSplashScreen: {fileID: 0} - iPadLandscapeSplashScreen: {fileID: 0} - iPadHighResLandscapeSplashScreen: {fileID: 0} - iPhone65inPortraitSplashScreen: {fileID: 0} - iPhone65inLandscapeSplashScreen: {fileID: 0} - iPhone61inPortraitSplashScreen: {fileID: 0} - iPhone61inLandscapeSplashScreen: {fileID: 0} appleTVSplashScreen: {fileID: 0} appleTVSplashScreen2x: {fileID: 0} tvOSSmallIconLayers: [] @@ -232,32 +217,47 @@ PlayerSettings: iOSLaunchScreeniPadFillPct: 100 iOSLaunchScreeniPadSize: 100 iOSLaunchScreeniPadCustomXibPath: - iOSUseLaunchScreenStoryboard: 0 iOSLaunchScreenCustomStoryboardPath: + iOSLaunchScreeniPadCustomStoryboardPath: iOSDeviceRequirements: [] iOSURLSchemes: [] + macOSURLSchemes: [] iOSBackgroundModes: 0 iOSMetalForceHardShadows: 0 metalEditorSupport: 1 metalAPIValidation: 1 iOSRenderExtraFrameOnPause: 0 + iosCopyPluginsCodeInsteadOfSymlink: 0 appleDeveloperTeamID: iOSManualSigningProvisioningProfileID: tvOSManualSigningProvisioningProfileID: + VisionOSManualSigningProvisioningProfileID: iOSManualSigningProvisioningProfileType: 0 tvOSManualSigningProvisioningProfileType: 0 + VisionOSManualSigningProvisioningProfileType: 0 appleEnableAutomaticSigning: 0 iOSRequireARKit: 0 iOSAutomaticallyDetectAndAddCapabilities: 1 appleEnableProMotion: 0 + shaderPrecisionModel: 0 clonedFromGUID: c0afd0d1d80e3634a9dac47e8a0426ea templatePackageId: com.unity.template.3d@1.0.11 templateDefaultScene: Assets/Scenes/SampleScene.unity + useCustomMainManifest: 0 + useCustomLauncherManifest: 0 + useCustomMainGradleTemplate: 0 + useCustomLauncherGradleManifest: 0 + useCustomBaseGradleTemplate: 0 + useCustomGradlePropertiesTemplate: 0 + useCustomGradleSettingsTemplate: 0 + useCustomProguardFile: 0 AndroidTargetArchitectures: 1 + AndroidTargetDevices: 0 AndroidSplashScreenScale: 0 androidSplashScreen: {fileID: 0} AndroidKeystoreName: '{inproject}: ' AndroidKeyaliasName: + AndroidEnableArmv9SecurityFeatures: 0 AndroidBuildApkPerCpuArchitecture: 0 AndroidTVCompatibility: 0 AndroidIsGame: 1 @@ -270,10 +270,105 @@ PlayerSettings: height: 180 banner: {fileID: 0} androidGamepadSupportLevel: 0 + chromeosInputEmulation: 1 + AndroidMinifyRelease: 0 + AndroidMinifyDebug: 0 AndroidValidateAppBundleSize: 1 AndroidAppBundleSizeToValidate: 100 m_BuildTargetIcons: [] - m_BuildTargetPlatformIcons: [] + m_BuildTargetPlatformIcons: + - m_BuildTarget: Android + m_Icons: + - m_Textures: [] + m_Width: 432 + m_Height: 432 + m_Kind: 2 + m_SubKind: + - m_Textures: [] + m_Width: 324 + m_Height: 324 + m_Kind: 2 + m_SubKind: + - m_Textures: [] + m_Width: 216 + m_Height: 216 + m_Kind: 2 + m_SubKind: + - m_Textures: [] + m_Width: 162 + m_Height: 162 + m_Kind: 2 + m_SubKind: + - m_Textures: [] + m_Width: 108 + m_Height: 108 + m_Kind: 2 + m_SubKind: + - m_Textures: [] + m_Width: 81 + m_Height: 81 + m_Kind: 2 + m_SubKind: + - m_Textures: [] + m_Width: 192 + m_Height: 192 + m_Kind: 0 + m_SubKind: + - m_Textures: [] + m_Width: 144 + m_Height: 144 + m_Kind: 0 + m_SubKind: + - m_Textures: [] + m_Width: 96 + m_Height: 96 + m_Kind: 0 + m_SubKind: + - m_Textures: [] + m_Width: 72 + m_Height: 72 + m_Kind: 0 + m_SubKind: + - m_Textures: [] + m_Width: 48 + m_Height: 48 + m_Kind: 0 + m_SubKind: + - m_Textures: [] + m_Width: 36 + m_Height: 36 + m_Kind: 0 + m_SubKind: + - m_Textures: [] + m_Width: 192 + m_Height: 192 + m_Kind: 1 + m_SubKind: + - m_Textures: [] + m_Width: 144 + m_Height: 144 + m_Kind: 1 + m_SubKind: + - m_Textures: [] + m_Width: 96 + m_Height: 96 + m_Kind: 1 + m_SubKind: + - m_Textures: [] + m_Width: 72 + m_Height: 72 + m_Kind: 1 + m_SubKind: + - m_Textures: [] + m_Width: 48 + m_Height: 48 + m_Kind: 1 + m_SubKind: + - m_Textures: [] + m_Width: 36 + m_Height: 36 + m_Kind: 1 + m_SubKind: m_BuildTargetBatching: - m_BuildTarget: Standalone m_StaticBatching: 1 @@ -290,6 +385,7 @@ PlayerSettings: - m_BuildTarget: WebGL m_StaticBatching: 0 m_DynamicBatching: 0 + m_BuildTargetShaderSettings: [] m_BuildTargetGraphicsJobs: - m_BuildTarget: MacStandaloneSupport m_GraphicsJobs: 0 @@ -325,13 +421,13 @@ PlayerSettings: m_BuildTargetGraphicsAPIs: - m_BuildTarget: AndroidPlayer m_APIs: 150000000b000000 - m_Automatic: 0 + m_Automatic: 1 - m_BuildTarget: iOSSupport m_APIs: 10000000 m_Automatic: 1 - m_BuildTarget: AppleTVSupport m_APIs: 10000000 - m_Automatic: 0 + m_Automatic: 1 - m_BuildTarget: WebGLSupport m_APIs: 0b000000 m_Automatic: 1 @@ -341,6 +437,8 @@ PlayerSettings: m_Devices: - Oculus - OpenVR + m_DefaultShaderChunkSizeInMB: 16 + m_DefaultShaderChunkCount: 0 openGLRequireES31: 0 openGLRequireES31AEP: 0 openGLRequireES32: 0 @@ -350,7 +448,11 @@ PlayerSettings: iPhone: 1 tvOS: 1 m_BuildTargetGroupLightmapEncodingQuality: [] + m_BuildTargetGroupHDRCubemapEncodingQuality: [] m_BuildTargetGroupLightmapSettings: [] + m_BuildTargetGroupLoadStoreDebugModeSettings: [] + m_BuildTargetNormalMapEncoding: [] + m_BuildTargetDefaultTextureCompressionFormat: [] playModeTestRunnerEnabled: 0 runPlayModeTestAsEditModeTest: 0 actionOnDotNetUnhandledException: 1 @@ -360,14 +462,20 @@ PlayerSettings: cameraUsageDescription: locationUsageDescription: microphoneUsageDescription: + bluetoothUsageDescription: + macOSTargetOSVersion: 10.13.0 + switchNMETAOverride: switchNetLibKey: switchSocketMemoryPoolSize: 6144 switchSocketAllocatorPoolSize: 128 switchSocketConcurrencyLimit: 14 switchScreenResolutionBehavior: 2 switchUseCPUProfiler: 0 + switchUseGOLDLinker: 0 + switchLTOSetting: 0 switchApplicationID: 0x01004b9000490000 switchNSODependencies: + switchCompilerFlags: switchTitleNames_0: switchTitleNames_1: switchTitleNames_2: @@ -383,6 +491,7 @@ PlayerSettings: switchTitleNames_12: switchTitleNames_13: switchTitleNames_14: + switchTitleNames_15: switchPublisherNames_0: switchPublisherNames_1: switchPublisherNames_2: @@ -398,6 +507,7 @@ PlayerSettings: switchPublisherNames_12: switchPublisherNames_13: switchPublisherNames_14: + switchPublisherNames_15: switchIcons_0: {fileID: 0} switchIcons_1: {fileID: 0} switchIcons_2: {fileID: 0} @@ -413,6 +523,7 @@ PlayerSettings: switchIcons_12: {fileID: 0} switchIcons_13: {fileID: 0} switchIcons_14: {fileID: 0} + switchIcons_15: {fileID: 0} switchSmallIcons_0: {fileID: 0} switchSmallIcons_1: {fileID: 0} switchSmallIcons_2: {fileID: 0} @@ -428,6 +539,7 @@ PlayerSettings: switchSmallIcons_12: {fileID: 0} switchSmallIcons_13: {fileID: 0} switchSmallIcons_14: {fileID: 0} + switchSmallIcons_15: {fileID: 0} switchManualHTML: switchAccessibleURLs: switchLegalInformation: @@ -437,7 +549,6 @@ PlayerSettings: switchReleaseVersion: 0 switchDisplayVersion: 1.0.0 switchStartupUserAccount: 0 - switchTouchScreenUsage: 0 switchSupportedLanguagesMask: 0 switchLogoType: 0 switchApplicationErrorCodeCategory: @@ -479,6 +590,7 @@ PlayerSettings: switchNativeFsCacheSize: 32 switchIsHoldTypeHorizontal: 0 switchSupportedNpadCount: 8 + switchEnableTouchScreen: 1 switchSocketConfigEnabled: 0 switchTcpInitialSendBufferSize: 32 switchTcpInitialReceiveBufferSize: 64 @@ -490,6 +602,12 @@ PlayerSettings: switchSocketInitializeEnabled: 1 switchNetworkInterfaceManagerInitializeEnabled: 1 switchPlayerConnectionEnabled: 1 + switchUseNewStyleFilepaths: 1 + switchUseLegacyFmodPriorities: 0 + switchUseMicroSleepForYield: 1 + switchEnableRamDiskSupport: 0 + switchMicroSleepForYieldTime: 25 + switchRamDiskSpaceSize: 12 ps4NPAgeRating: 12 ps4NPTitleSecret: ps4NPTrophyPackPath: @@ -516,6 +634,7 @@ PlayerSettings: ps4ShareFilePath: ps4ShareOverlayImagePath: ps4PrivacyGuardImagePath: + ps4ExtraSceSysFile: ps4NPtitleDatPath: ps4RemotePlayKeyAssignment: -1 ps4RemotePlayKeyMappingDir: @@ -541,6 +660,7 @@ PlayerSettings: ps4UseResolutionFallback: 0 ps4ReprojectionSupport: 0 ps4UseAudio3dBackend: 0 + ps4UseLowGarlicFragmentationMode: 1 ps4SocialScreenEnabled: 0 ps4ScriptOptimizationLevel: 0 ps4Audio3dVirtualSpeakerCount: 14 @@ -557,6 +677,9 @@ PlayerSettings: ps4disableAutoHideSplash: 0 ps4videoRecordingFeaturesUsed: 0 ps4contentSearchFeaturesUsed: 0 + ps4CompatibilityPS5: 0 + ps4AllowPS5Detection: 0 + ps4GPU800MHz: 1 ps4attribEyeToEyeDistanceSettingVR: 0 ps4IncludedModules: [] ps4attribVROutputEnabled: 0 @@ -568,6 +691,7 @@ PlayerSettings: webGLMemorySize: 16 webGLExceptionSupport: 1 webGLNameFilesAsHashes: 0 + webGLShowDiagnostics: 0 webGLDataCaching: 1 webGLDebugSymbols: 0 webGLEmscriptenArgs: @@ -576,16 +700,45 @@ PlayerSettings: webGLAnalyzeBuildSize: 0 webGLUseEmbeddedResources: 0 webGLCompressionFormat: 1 + webGLWasmArithmeticExceptions: 0 webGLLinkerTarget: 1 webGLThreadsSupport: 0 - webGLWasmStreaming: 0 + webGLDecompressionFallback: 0 + webGLInitialMemorySize: 32 + webGLMaximumMemorySize: 2048 + webGLMemoryGrowthMode: 2 + webGLMemoryLinearGrowthStep: 16 + webGLMemoryGeometricGrowthStep: 0.2 + webGLMemoryGeometricGrowthCap: 96 + webGLPowerPreference: 2 scriptingDefineSymbols: {} + additionalCompilerArguments: {} platformArchitecture: {} - scriptingBackend: {} + scriptingBackend: + Android: 1 + Standalone: 1 il2cppCompilerConfiguration: {} - managedStrippingLevel: {} + il2cppCodeGeneration: {} + managedStrippingLevel: + Android: 1 + EmbeddedLinux: 1 + GameCoreScarlett: 1 + GameCoreXboxOne: 1 + Nintendo Switch: 1 + PS4: 1 + PS5: 1 + QNX: 1 + Stadia: 1 + VisionOS: 1 + WebGL: 1 + Windows Store Apps: 1 + XboxOne: 1 + iPhone: 1 + tvOS: 1 incrementalIl2cppBuild: {} - allowUnsafeCode: 0 + suppressCommonWarnings: 1 + allowUnsafeCode: 1 + useDeterministicCompilation: 1 additionalIl2CppArgs: scriptingRuntimeVersion: 1 gcIncremental: 0 @@ -620,6 +773,7 @@ PlayerSettings: metroFTAName: metroFTAFileTypes: [] metroProtocolName: + vcxProjDefaultLanguage: XboxOneProductId: XboxOneUpdateKey: XboxOneSandboxId: @@ -638,6 +792,7 @@ PlayerSettings: XboxOneCapability: [] XboxOneGameRating: {} XboxOneIsContentPackage: 0 + XboxOneEnhancedXboxCompatibilityMode: 0 XboxOneEnableGPUVariability: 0 XboxOneSockets: {} XboxOneSplashScreen: {fileID: 0} @@ -645,10 +800,8 @@ PlayerSettings: XboxOnePersistentLocalStorageSize: 0 XboxOneXTitleMemory: 8 XboxOneOverrideIdentityName: - vrEditorSettings: - daydream: - daydreamIconForeground: {fileID: 0} - daydreamIconBackground: {fileID: 0} + XboxOneOverrideIdentityPublisher: + vrEditorSettings: {} cloudServicesEnabled: UNet: 1 luminIcon: @@ -662,12 +815,22 @@ PlayerSettings: luminVersion: m_VersionCode: 1 m_VersionName: + hmiPlayerDataPath: + hmiForceSRGBBlit: 1 + embeddedLinuxEnableGamepadInput: 1 + hmiLogStartupTiming: 0 + hmiCpuConfiguration: apiCompatibilityLevel: 6 + activeInputHandler: 0 + windowsGamepadBackendHint: 0 cloudProjectId: framebufferDepthMemorylessMode: 0 + qualitySettingsNames: [] projectName: organizationId: cloudEnabled: 0 - enableNativePlatformBackendsForNewInputSystem: 0 - disableOldInputManagerSupport: 0 legacyClampBlendShapeWeights: 1 + hmiLoadingImage: {fileID: 0} + platformRequiresReadableAssets: 0 + virtualTexturingSupportEnabled: 0 + insecureHttpOption: 0 diff --git a/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt b/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt index 798259ba..78a77889 100644 --- a/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt +++ b/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt @@ -1,2 +1,2 @@ -m_EditorVersion: 2019.3.0f6 -m_EditorVersionWithRevision: 2019.3.0f6 (27ab2135bccf) +m_EditorVersion: 2022.3.7f1 +m_EditorVersionWithRevision: 2022.3.7f1 (b16b3b16c7a0) diff --git a/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset index fa0b1465..a88bee0f 100644 --- a/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset +++ b/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset @@ -9,6 +9,7 @@ UnityConnectSettings: m_EventOldUrl: https://api.uca.cloud.unity3d.com/v1/events m_EventUrl: https://cdp.cloud.unity3d.com/v1/events m_ConfigUrl: https://config.uca.cloud.unity3d.com + m_DashboardUrl: https://dashboard.unity3d.com m_TestInitMode: 0 CrashReportingSettings: m_EventUrl: https://perf-events.cloud.unity3d.com @@ -22,6 +23,7 @@ UnityConnectSettings: m_Enabled: 0 m_TestMode: 0 m_InitializeOnStartup: 1 + m_PackageRequiringCoreStatsPresent: 0 UnityAdsSettings: m_Enabled: 0 m_InitializeOnStartup: 1 diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 4a2f3065..8367c2b0 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -6,7 +6,7 @@ ### Deprecated ### Removed ### Fixed - +* Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices. ## [1.3.0] 2023-07-12 diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs index a5b31efe..77af61f8 100644 --- a/src/Tests/Tests/Shared/TestAffineTransform.cs +++ b/src/Tests/Tests/Shared/TestAffineTransform.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestAffineTransform { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_construct_from_float3x3() { const float tolerance = 1e-6f; @@ -20,7 +20,7 @@ public static void affine_transform_construct_from_float3x3() TestUtils.AreEqual(m3x3, testM3x3, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_construct_from_float3x4() { const float tolerance = 1e-6f; @@ -33,7 +33,7 @@ public static void affine_transform_construct_from_float3x4() TestUtils.AreEqual(m3x4, testM3x4, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_construct_from_float4x4() { const float tolerance = 1e-6f; @@ -46,7 +46,7 @@ public static void affine_transform_construct_from_float4x4() TestUtils.AreEqual(m4x4, testM4x4, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_construct_from_RigidTransform() { const float tolerance = 1e-6f; @@ -58,7 +58,7 @@ public static void affine_transform_construct_from_RigidTransform() TestUtils.AreEqual(r.pos, tx.t, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_inverse() { const float tolerance = 1e-6f; @@ -69,7 +69,7 @@ public static void affine_transform_inverse() TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_inverse_zero_rs_returns_zero() { const float tolerance = 1e-30f; @@ -80,7 +80,7 @@ public static void affine_transform_inverse_zero_rs_returns_zero() TestUtils.AreEqual(float3x4.zero, invTx, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_inverse_pico_scale() { // slightly larger tolerance (vs 1e-6f) for PS4 @@ -92,7 +92,7 @@ public static void affine_transform_inverse_pico_scale() TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_inverse_singular() { // it needs a bit larger tolerance for singular @@ -107,7 +107,7 @@ public static void affine_transform_inverse_singular() TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_decompose() { const float tolerance = 1e-6f; @@ -120,7 +120,7 @@ public static void affine_transform_decompose() TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_mul_vector() { float4x4 m = TestMatrix.test4x4_xyz; @@ -137,7 +137,7 @@ public static void affine_transform_mul_vector() TestUtils.AreEqual(mvector1, txvector1, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_rotate_vector() { float3x3 m = TestMatrix.test3x3_xyz; @@ -150,7 +150,7 @@ public static void affine_transform_rotate_vector() TestUtils.AreEqual(mvector0, txvector0, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_transform_point() { float4x4 m = float4x4(TestMatrix.test3x3_zyx, float3(1f, 2f, 3f)); @@ -163,7 +163,7 @@ public static void affine_transform_transform_point() TestUtils.AreEqual(mPt0, txPt0, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void affine_transform_zero() { TestUtils.AreEqual(float3x3.zero, AffineTransform.zero.rs); diff --git a/src/Tests/Tests/Shared/TestBitmanipulation.cs b/src/Tests/Tests/Shared/TestBitmanipulation.cs index 517d8d67..e3c91791 100644 --- a/src/Tests/Tests/Shared/TestBitmanipulation.cs +++ b/src/Tests/Tests/Shared/TestBitmanipulation.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBitmanipulation { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bitmask_bool4() { TestUtils.AreEqual(bitmask(new bool4(false, false, false, false)), 0b0000); @@ -23,7 +23,7 @@ public static void bitmask_bool4() TestUtils.AreEqual(bitmask(new bool4(true, true, true, false)), 0b0111); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_int1() { TestUtils.AreEqual(12, countbits( 0x01234567)); @@ -33,7 +33,7 @@ public static void countbits_int1() TestUtils.AreEqual(32, countbits(-1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_int2() { TestUtils.AreEqual(int2(0, 12), countbits(int2(0, 0x01234567))); @@ -41,21 +41,21 @@ public static void countbits_int2() TestUtils.AreEqual(int2(17, 32), countbits(int2(-0x456789AB, -1))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_int3() { TestUtils.AreEqual(int3(0, 12, 16), countbits(int3(0, 0x01234567, 0x456789AB))); TestUtils.AreEqual(int3(21, 17, 32), countbits(int3(-0x01234567, -0x456789AB, -1))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_int4() { TestUtils.AreEqual(int4(0, 12, 16, 21), countbits(int4(0, 0x01234567, 0x456789AB, -0x01234567))); TestUtils.AreEqual(int4(17, 32, 30, 29), countbits(int4(-0x456789AB, -1, -7, -15))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_uint() { TestUtils.AreEqual(0, countbits(0u)); @@ -66,7 +66,7 @@ public static void countbits_uint() TestUtils.AreEqual(32, countbits(0xFFFFFFFFu)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_uint2() { TestUtils.AreEqual(int2(0, 12), countbits(uint2(0, 0x01234567))); @@ -74,21 +74,21 @@ public static void countbits_uint2() TestUtils.AreEqual(int2(16, 32), countbits(uint2(0xCDEF0123u, 0xFFFFFFFFu))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_uint3() { TestUtils.AreEqual(int3(0, 12, 16), countbits(uint3(0, 0x01234567, 0x456789AB))); TestUtils.AreEqual(int3(20, 16, 32), countbits(uint3(0x89ABCDEFu, 0xCDEF0123u, 0xFFFFFFFFu))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_uint4() { TestUtils.AreEqual(int4(0, 12, 16, 20), countbits(uint4(0, 0x01234567, 0x456789AB, 0x89ABCDEFu))); TestUtils.AreEqual(int4(16, 32, 30, 29), countbits(uint4(0xCDEF0123u, 0xFFFFFFFFu, 0xFFFFFFF5u, 0xFFFFFFF1u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_long() { TestUtils.AreEqual(0, countbits(0L)); @@ -97,7 +97,7 @@ public static void countbits_long() TestUtils.AreEqual(64, countbits(-1L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void countbits_ulong() { TestUtils.AreEqual(0, countbits(0UL)); @@ -106,7 +106,7 @@ public static void countbits_ulong() TestUtils.AreEqual(64, countbits(0xFFFFFFFFFFFFFFFFUL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_int() { TestUtils.AreEqual(32, lzcnt(0)); @@ -119,7 +119,7 @@ public static void lzcnt_int() TestUtils.AreEqual(0, lzcnt(-2147483648)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_int2() { TestUtils.AreEqual(int2(32, 31), lzcnt(int2(0, 1))); @@ -128,7 +128,7 @@ public static void lzcnt_int2() TestUtils.AreEqual(int2(0, 0), lzcnt(int2(-1, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_int3() { TestUtils.AreEqual(int3(32, 31, 30), lzcnt(int3(0, 1, 2))); @@ -136,14 +136,14 @@ public static void lzcnt_int3() TestUtils.AreEqual(int3(0, 0, 27), lzcnt(int3(-1, -2147483648, 17))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_int4() { TestUtils.AreEqual(int4(32, 31, 30, 30), lzcnt(int4(0, 1, 2, 3))); TestUtils.AreEqual(int4(17, 5, 0, 0), lzcnt(int4(0x5321, 0x04435321, -1, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_uint() { TestUtils.AreEqual(32, lzcnt(0u)); @@ -156,7 +156,7 @@ public static void lzcnt_uint() TestUtils.AreEqual(0, lzcnt(0xFFFFFFFFu)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_uint2() { TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u))); @@ -165,7 +165,7 @@ public static void lzcnt_uint2() TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_uint3() { TestUtils.AreEqual(int3(32, 31, 30), lzcnt(uint3(0u, 1u, 2u))); @@ -173,7 +173,7 @@ public static void lzcnt_uint3() TestUtils.AreEqual(int3(0, 0, 27), lzcnt(uint3(0x84435320u, 0xFFFFFFFFu, 17))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_uint4() { TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u))); @@ -182,7 +182,7 @@ public static void lzcnt_uint4() TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_long() { TestUtils.AreEqual(64, lzcnt(0L)); @@ -194,7 +194,7 @@ public static void lzcnt_long() TestUtils.AreEqual(0, lzcnt(-9223372036854775808L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lzcnt_ulong() { TestUtils.AreEqual(64, lzcnt(0UL)); @@ -206,7 +206,7 @@ public static void lzcnt_ulong() TestUtils.AreEqual(0, lzcnt(0x8000000000000000UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_int() { TestUtils.AreEqual(32, tzcnt(0)); @@ -220,7 +220,7 @@ public static void tzcnt_int() TestUtils.AreEqual(31, tzcnt(-2147483648)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_int2() { TestUtils.AreEqual(int2(32, 0), tzcnt(int2(0, 1))); @@ -230,7 +230,7 @@ public static void tzcnt_int2() TestUtils.AreEqual(int2(31, 2), tzcnt(int2(-2147483648, 20))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_int3() { TestUtils.AreEqual(int3(32, 0, 1), tzcnt(int3(0, 1, 2))); @@ -238,7 +238,7 @@ public static void tzcnt_int3() TestUtils.AreEqual(int3(1, 0, 31), tzcnt(int3(-2, -2147483647, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_int4() { TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(int4(0, 1, 2, 3))); @@ -246,7 +246,7 @@ public static void tzcnt_int4() TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(int4(-2147483648, 20, 4132, -8))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_uint() { TestUtils.AreEqual(32, tzcnt(0u)); @@ -260,7 +260,7 @@ public static void tzcnt_uint() TestUtils.AreEqual(31, tzcnt(0x80000000u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_uint2() { TestUtils.AreEqual(int2(32, 0), tzcnt(uint2(0u, 1u))); @@ -270,7 +270,7 @@ public static void tzcnt_uint2() TestUtils.AreEqual(int2(31, 2), tzcnt(uint2(0x80000000u, 20u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_uint3() { TestUtils.AreEqual(int3(32, 0, 1), tzcnt(uint3(0u, 1u, 2u))); @@ -278,7 +278,7 @@ public static void tzcnt_uint3() TestUtils.AreEqual(int3(1, 0, 31), tzcnt(uint3(0xFFFFFFFEu, 0x80000001u, 0x80000000u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_uint4() { TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(uint4(0u, 1u, 2u, 3u))); @@ -286,7 +286,7 @@ public static void tzcnt_uint4() TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(uint4(0x80000000u, 20u, 4132u, 0xFFFFFFF8u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_long() { TestUtils.AreEqual(64, tzcnt(0L)); @@ -298,7 +298,7 @@ public static void tzcnt_long() TestUtils.AreEqual(0, tzcnt(-9223372036854775807L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tzcnt_ulong() { TestUtils.AreEqual(64, tzcnt(0UL)); @@ -310,7 +310,7 @@ public static void tzcnt_ulong() TestUtils.AreEqual(0, tzcnt(0x8000000000000001UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_int() { TestUtils.AreEqual(0x03521609, reversebits(-1872213312)); @@ -319,27 +319,27 @@ public static void reversebits_int() TestUtils.AreEqual(0x48d9c42e, reversebits(0x74239b12)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_int2() { TestUtils.AreEqual(int2(0x03521609, 0x5f5b0648), reversebits(int2(-1872213312, 0x1260dafa))); TestUtils.AreEqual(int2(0x4bbafd8d, 0x48d9c42e), reversebits(int2(-1312858670, 0x74239b12))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_int3() { TestUtils.AreEqual(int3(0x03521609, 0x5f5b0648, 0x4bbafd8d), reversebits(int3(-1872213312, 0x1260dafa, -1312858670))); TestUtils.AreEqual(int3(0x48d9c42e, 0, -1), reversebits(int3(0x74239b12, 0, -1))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_int4() { TestUtils.AreEqual(int4(0x03521609, 0x5f5b0648, 0x4bbafd8d, 0x48d9c42e), reversebits(int4(-1872213312, 0x1260dafa, -1312858670, 0x74239b12))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_uint() { TestUtils.AreEqual(0x03521609u, reversebits(0x90684ac0u)); @@ -348,39 +348,39 @@ public static void reversebits_uint() TestUtils.AreEqual(0x48d9c42eu, reversebits(0x74239b12u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_uint2() { TestUtils.AreEqual(uint2(0x03521609u, 0x5f5b0648u), reversebits(uint2(0x90684ac0u, 0x1260dafau))); TestUtils.AreEqual(uint2(0x4bbafd8du, 0x48d9c42eu), reversebits(uint2(0xb1bf5dd2u, 0x74239b12u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_uint3() { TestUtils.AreEqual(uint3(0x03521609u, 0x5f5b0648u, 0x4bbafd8du), reversebits(uint3(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u))); TestUtils.AreEqual(uint3(0x48d9c42eu, 0u, 0xFFFFFFFF), reversebits(uint3(0x74239b12u, 0u, 0xFFFFFFFF))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_uint4() { TestUtils.AreEqual(uint4(0x03521609u, 0x5f5b0648u, 0x4bbafd8du, 0x48d9c42eu), reversebits(uint4(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u, 0x74239b12u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_long() { TestUtils.AreEqual(0x4bbafd8d5f5b0648L, reversebits(0x1260dafab1bf5dd2L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reversebits_ulong() { TestUtils.AreEqual(0x4bbafd8d5f5b0648ul, reversebits(0x1260dafab1bf5dd2ul)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_int() { TestUtils.AreEqual(-1933184920, rol(219257022, 11)); @@ -389,27 +389,27 @@ public static void rol_int() TestUtils.AreEqual(661621977, rol(-1692078607, 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_int2() { TestUtils.AreEqual(int2(-1933184920, -2048170741), rol(int2(219257022, -1586446996), 11)); TestUtils.AreEqual(int2(-1152739462, 661621977), rol(int2(-279484078, -1692078607), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_int3() { TestUtils.AreEqual(int3(-1933184920, -2048170741, -1152739462), rol(int3(219257022, -1586446996, -279484078), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_int4() { TestUtils.AreEqual(int4(-1933184920, -2048170741, -1152739462, 661621977), rol(int4(219257022, -1586446996, -279484078, -1692078607), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_uint() { TestUtils.AreEqual(2361782376u, rol(219257022u, 11)); @@ -418,27 +418,27 @@ public static void rol_uint() TestUtils.AreEqual(661621977u, rol(2602888689u, 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_uint2() { TestUtils.AreEqual(uint2(2361782376u, 2246796555u), rol(uint2(219257022u, 2708520300u), 11)); TestUtils.AreEqual(uint2(3142227834u, 661621977u), rol(uint2(4015483218u, 2602888689u), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_uint3() { TestUtils.AreEqual(uint3(2361782376u, 2246796555u, 3142227834u), rol(uint3(219257022u, 2708520300u, 4015483218u), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_uint4() { TestUtils.AreEqual(uint4(2361782376u, 2246796555u, 3142227834u, 661621977u), rol(uint4(219257022u, 2708520300u, 4015483218u, 2602888689u), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_long() { TestUtils.AreEqual(4769317691753349395L, rol(6894885722123239465L, 37)); @@ -447,7 +447,7 @@ public static void rol_long() TestUtils.AreEqual(-5493728106787075631L, rol(2788577329702376155L, 37)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rol_ulong() { TestUtils.AreEqual(4769317691753349395UL, rol(6894885722123239465UL, 37)); @@ -457,7 +457,7 @@ public static void rol_ulong() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_int() { TestUtils.AreEqual(87245360, ror(-1710129111, 11)); @@ -466,27 +466,27 @@ public static void ror_int() TestUtils.AreEqual(-232831845, ror(-98246768, 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_int2() { TestUtils.AreEqual(int2(87245360, -259445220), ror(int2(-1710129111, 1232136068), 11)); TestUtils.AreEqual(int2(-1697813787, -232831845), ror(int2(1800875222, -98246768), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_int3() { TestUtils.AreEqual(int3(87245360, -259445220, -1697813787), ror(int3(-1710129111, 1232136068, 1800875222), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_int4() { TestUtils.AreEqual(int4(87245360, -259445220, -1697813787, -232831845), ror(int4(-1710129111, 1232136068, 1800875222, -98246768), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_uint() { TestUtils.AreEqual(87245360u, ror(2584838185u, 11)); @@ -495,26 +495,26 @@ public static void ror_uint() TestUtils.AreEqual(4062135451u, ror(4196720528u, 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_uint2() { TestUtils.AreEqual(uint2(87245360u, 4035522076u), ror(uint2(2584838185u, 1232136068u), 11)); TestUtils.AreEqual(uint2(2597153509u, 4062135451u), ror(uint2(1800875222u, 4196720528u), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_uint3() { TestUtils.AreEqual(uint3(87245360u, 4035522076u, 2597153509u), ror(uint3(2584838185u, 1232136068u, 1800875222u), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_uint4() { TestUtils.AreEqual(uint4(87245360u, 4035522076u, 2597153509u, 4062135451u), ror(uint4(2584838185u, 1232136068u, 1800875222u, 4196720528u), 11)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_long() { TestUtils.AreEqual(4958617126915898480L, ror(6894885722123239465L, 37)); @@ -523,7 +523,7 @@ public static void ror_long() TestUtils.AreEqual(8389344736564320290L, ror(2788577329702376155L, 37)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ror_ulong() { TestUtils.AreEqual(4958617126915898480UL, ror(6894885722123239465UL, 37)); diff --git a/src/Tests/Tests/Shared/TestBool2.gen.cs b/src/Tests/Tests/Shared/TestBool2.gen.cs index 3546ddd3..fe9ee45c 100644 --- a/src/Tests/Tests/Shared/TestBool2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_constructor() { bool2 a = new bool2(false, true); @@ -23,7 +23,7 @@ public static void bool2_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_scalar_constructor() { bool2 a = new bool2(true); @@ -31,7 +31,7 @@ public static void bool2_scalar_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_static_constructor() { bool2 a = bool2(false, true); @@ -39,7 +39,7 @@ public static void bool2_static_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_static_scalar_constructor() { bool2 a = bool2(true); @@ -47,7 +47,7 @@ public static void bool2_static_scalar_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_equal_wide_wide() { bool2 a0 = bool2(true, false); @@ -71,7 +71,7 @@ public static void bool2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_equal_wide_scalar() { bool2 a0 = bool2(false, true); @@ -95,7 +95,7 @@ public static void bool2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_equal_scalar_wide() { bool a0 = (false); @@ -119,7 +119,7 @@ public static void bool2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_not_equal_wide_wide() { bool2 a0 = bool2(true, true); @@ -143,7 +143,7 @@ public static void bool2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_not_equal_wide_scalar() { bool2 a0 = bool2(false, true); @@ -167,7 +167,7 @@ public static void bool2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -191,7 +191,7 @@ public static void bool2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_and_wide_wide() { bool2 a0 = bool2(false, false); @@ -215,7 +215,7 @@ public static void bool2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_and_wide_scalar() { bool2 a0 = bool2(true, false); @@ -239,7 +239,7 @@ public static void bool2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -263,7 +263,7 @@ public static void bool2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_or_wide_wide() { bool2 a0 = bool2(true, true); @@ -287,7 +287,7 @@ public static void bool2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_or_wide_scalar() { bool2 a0 = bool2(true, true); @@ -311,7 +311,7 @@ public static void bool2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -335,7 +335,7 @@ public static void bool2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_xor_wide_wide() { bool2 a0 = bool2(true, false); @@ -359,7 +359,7 @@ public static void bool2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_xor_wide_scalar() { bool2 a0 = bool2(false, false); @@ -383,7 +383,7 @@ public static void bool2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -407,7 +407,7 @@ public static void bool2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_operator_logical_not() { bool2 a0 = bool2(true, true); @@ -427,7 +427,7 @@ public static void bool2_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool2_EqualsObjectOverride() { TestUtils.IsFalse(new bool2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool2x2.gen.cs b/src/Tests/Tests/Shared/TestBool2x2.gen.cs index dbfd2fa1..af2bb68c 100644 --- a/src/Tests/Tests/Shared/TestBool2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_equal_wide_wide() { bool2x2 a0 = bool2x2(true, false, true, false); @@ -39,7 +39,7 @@ public static void bool2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_equal_wide_scalar() { bool2x2 a0 = bool2x2(false, true, false, false); @@ -63,7 +63,7 @@ public static void bool2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_not_equal_wide_wide() { bool2x2 a0 = bool2x2(true, true, true, false); @@ -111,7 +111,7 @@ public static void bool2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_not_equal_wide_scalar() { bool2x2 a0 = bool2x2(false, true, false, true); @@ -135,7 +135,7 @@ public static void bool2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_and_wide_wide() { bool2x2 a0 = bool2x2(false, false, true, true); @@ -183,7 +183,7 @@ public static void bool2x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_and_wide_scalar() { bool2x2 a0 = bool2x2(true, false, false, true); @@ -207,7 +207,7 @@ public static void bool2x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool2x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_or_wide_wide() { bool2x2 a0 = bool2x2(true, true, true, false); @@ -255,7 +255,7 @@ public static void bool2x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_or_wide_scalar() { bool2x2 a0 = bool2x2(true, true, false, true); @@ -279,7 +279,7 @@ public static void bool2x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool2x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_xor_wide_wide() { bool2x2 a0 = bool2x2(true, false, false, true); @@ -327,7 +327,7 @@ public static void bool2x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_xor_wide_scalar() { bool2x2 a0 = bool2x2(false, false, true, true); @@ -351,7 +351,7 @@ public static void bool2x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool2x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x2_operator_logical_not() { bool2x2 a0 = bool2x2(true, true, false, false); @@ -395,7 +395,7 @@ public static void bool2x2_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool2x2_EqualsObjectOverride() { TestUtils.IsFalse(new bool2x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool2x3.gen.cs b/src/Tests/Tests/Shared/TestBool2x3.gen.cs index e0f8f2d3..bf0f34d2 100644 --- a/src/Tests/Tests/Shared/TestBool2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_equal_wide_wide() { bool2x3 a0 = bool2x3(true, false, true, false, false, true); @@ -39,7 +39,7 @@ public static void bool2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_equal_wide_scalar() { bool2x3 a0 = bool2x3(false, true, false, false, false, false); @@ -63,7 +63,7 @@ public static void bool2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_not_equal_wide_wide() { bool2x3 a0 = bool2x3(true, true, true, false, false, true); @@ -111,7 +111,7 @@ public static void bool2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_not_equal_wide_scalar() { bool2x3 a0 = bool2x3(false, true, false, true, true, false); @@ -135,7 +135,7 @@ public static void bool2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_and_wide_wide() { bool2x3 a0 = bool2x3(false, false, true, true, false, false); @@ -183,7 +183,7 @@ public static void bool2x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_and_wide_scalar() { bool2x3 a0 = bool2x3(true, false, false, true, true, false); @@ -207,7 +207,7 @@ public static void bool2x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool2x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_or_wide_wide() { bool2x3 a0 = bool2x3(true, true, true, false, true, false); @@ -255,7 +255,7 @@ public static void bool2x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_or_wide_scalar() { bool2x3 a0 = bool2x3(true, true, false, true, true, true); @@ -279,7 +279,7 @@ public static void bool2x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool2x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_xor_wide_wide() { bool2x3 a0 = bool2x3(true, false, false, true, false, false); @@ -327,7 +327,7 @@ public static void bool2x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_xor_wide_scalar() { bool2x3 a0 = bool2x3(false, false, true, true, false, false); @@ -351,7 +351,7 @@ public static void bool2x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool2x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x3_operator_logical_not() { bool2x3 a0 = bool2x3(true, true, false, false, true, false); @@ -395,7 +395,7 @@ public static void bool2x3_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool2x3_EqualsObjectOverride() { TestUtils.IsFalse(new bool2x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool2x4.gen.cs b/src/Tests/Tests/Shared/TestBool2x4.gen.cs index 4200e9ee..3310b755 100644 --- a/src/Tests/Tests/Shared/TestBool2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_equal_wide_wide() { bool2x4 a0 = bool2x4(true, false, true, false, false, true, false, false); @@ -39,7 +39,7 @@ public static void bool2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_equal_wide_scalar() { bool2x4 a0 = bool2x4(false, true, false, false, false, false, true, false); @@ -63,7 +63,7 @@ public static void bool2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_not_equal_wide_wide() { bool2x4 a0 = bool2x4(true, true, true, false, false, true, false, false); @@ -111,7 +111,7 @@ public static void bool2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_not_equal_wide_scalar() { bool2x4 a0 = bool2x4(false, true, false, true, true, false, false, false); @@ -135,7 +135,7 @@ public static void bool2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_and_wide_wide() { bool2x4 a0 = bool2x4(false, false, true, true, false, false, true, true); @@ -183,7 +183,7 @@ public static void bool2x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_and_wide_scalar() { bool2x4 a0 = bool2x4(true, false, false, true, true, false, false, false); @@ -207,7 +207,7 @@ public static void bool2x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool2x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_or_wide_wide() { bool2x4 a0 = bool2x4(true, true, true, false, true, false, true, true); @@ -255,7 +255,7 @@ public static void bool2x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_or_wide_scalar() { bool2x4 a0 = bool2x4(true, true, false, true, true, true, true, false); @@ -279,7 +279,7 @@ public static void bool2x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool2x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_xor_wide_wide() { bool2x4 a0 = bool2x4(true, false, false, true, false, false, false, true); @@ -327,7 +327,7 @@ public static void bool2x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_xor_wide_scalar() { bool2x4 a0 = bool2x4(false, false, true, true, false, false, false, false); @@ -351,7 +351,7 @@ public static void bool2x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool2x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2x4_operator_logical_not() { bool2x4 a0 = bool2x4(true, true, false, false, true, false, true, false); @@ -395,7 +395,7 @@ public static void bool2x4_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool2x4_EqualsObjectOverride() { TestUtils.IsFalse(new bool2x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool3.gen.cs b/src/Tests/Tests/Shared/TestBool3.gen.cs index e6b69c43..d66353aa 100644 --- a/src/Tests/Tests/Shared/TestBool3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_constructor() { bool3 a = new bool3(false, true, false); @@ -24,7 +24,7 @@ public static void bool3_constructor() TestUtils.AreEqual(false, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_scalar_constructor() { bool3 a = new bool3(true); @@ -33,7 +33,7 @@ public static void bool3_scalar_constructor() TestUtils.AreEqual(true, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_static_constructor() { bool3 a = bool3(false, true, false); @@ -42,7 +42,7 @@ public static void bool3_static_constructor() TestUtils.AreEqual(false, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_static_scalar_constructor() { bool3 a = bool3(true); @@ -51,7 +51,7 @@ public static void bool3_static_scalar_constructor() TestUtils.AreEqual(true, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_equal_wide_wide() { bool3 a0 = bool3(true, false, true); @@ -75,7 +75,7 @@ public static void bool3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_equal_wide_scalar() { bool3 a0 = bool3(false, true, false); @@ -99,7 +99,7 @@ public static void bool3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_equal_scalar_wide() { bool a0 = (false); @@ -123,7 +123,7 @@ public static void bool3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_not_equal_wide_wide() { bool3 a0 = bool3(true, true, true); @@ -147,7 +147,7 @@ public static void bool3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_not_equal_wide_scalar() { bool3 a0 = bool3(false, true, false); @@ -171,7 +171,7 @@ public static void bool3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -195,7 +195,7 @@ public static void bool3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_and_wide_wide() { bool3 a0 = bool3(false, false, true); @@ -219,7 +219,7 @@ public static void bool3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_and_wide_scalar() { bool3 a0 = bool3(true, false, false); @@ -243,7 +243,7 @@ public static void bool3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -267,7 +267,7 @@ public static void bool3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_or_wide_wide() { bool3 a0 = bool3(true, true, true); @@ -291,7 +291,7 @@ public static void bool3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_or_wide_scalar() { bool3 a0 = bool3(true, true, false); @@ -315,7 +315,7 @@ public static void bool3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -339,7 +339,7 @@ public static void bool3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_xor_wide_wide() { bool3 a0 = bool3(true, false, false); @@ -363,7 +363,7 @@ public static void bool3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_xor_wide_scalar() { bool3 a0 = bool3(false, false, true); @@ -387,7 +387,7 @@ public static void bool3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -411,7 +411,7 @@ public static void bool3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_operator_logical_not() { bool3 a0 = bool3(true, true, false); @@ -431,7 +431,7 @@ public static void bool3_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool3_EqualsObjectOverride() { TestUtils.IsFalse(new bool3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool3x2.gen.cs b/src/Tests/Tests/Shared/TestBool3x2.gen.cs index d41f918c..5be3fb7b 100644 --- a/src/Tests/Tests/Shared/TestBool3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_equal_wide_wide() { bool3x2 a0 = bool3x2(true, false, true, false, false, true); @@ -39,7 +39,7 @@ public static void bool3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_equal_wide_scalar() { bool3x2 a0 = bool3x2(false, true, false, false, false, false); @@ -63,7 +63,7 @@ public static void bool3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_not_equal_wide_wide() { bool3x2 a0 = bool3x2(true, true, true, false, false, true); @@ -111,7 +111,7 @@ public static void bool3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_not_equal_wide_scalar() { bool3x2 a0 = bool3x2(false, true, false, true, true, false); @@ -135,7 +135,7 @@ public static void bool3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_and_wide_wide() { bool3x2 a0 = bool3x2(false, false, true, true, false, false); @@ -183,7 +183,7 @@ public static void bool3x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_and_wide_scalar() { bool3x2 a0 = bool3x2(true, false, false, true, true, false); @@ -207,7 +207,7 @@ public static void bool3x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool3x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_or_wide_wide() { bool3x2 a0 = bool3x2(true, true, true, false, true, false); @@ -255,7 +255,7 @@ public static void bool3x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_or_wide_scalar() { bool3x2 a0 = bool3x2(true, true, false, true, true, true); @@ -279,7 +279,7 @@ public static void bool3x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool3x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_xor_wide_wide() { bool3x2 a0 = bool3x2(true, false, false, true, false, false); @@ -327,7 +327,7 @@ public static void bool3x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_xor_wide_scalar() { bool3x2 a0 = bool3x2(false, false, true, true, false, false); @@ -351,7 +351,7 @@ public static void bool3x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool3x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x2_operator_logical_not() { bool3x2 a0 = bool3x2(true, true, false, false, true, false); @@ -395,7 +395,7 @@ public static void bool3x2_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool3x2_EqualsObjectOverride() { TestUtils.IsFalse(new bool3x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool3x3.gen.cs b/src/Tests/Tests/Shared/TestBool3x3.gen.cs index 4a2301d9..4541a352 100644 --- a/src/Tests/Tests/Shared/TestBool3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_equal_wide_wide() { bool3x3 a0 = bool3x3(true, false, true, false, false, true, false, false, true); @@ -39,7 +39,7 @@ public static void bool3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_equal_wide_scalar() { bool3x3 a0 = bool3x3(false, true, false, false, false, false, true, false, false); @@ -63,7 +63,7 @@ public static void bool3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_not_equal_wide_wide() { bool3x3 a0 = bool3x3(true, true, true, false, false, true, false, false, false); @@ -111,7 +111,7 @@ public static void bool3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_not_equal_wide_scalar() { bool3x3 a0 = bool3x3(false, true, false, true, true, false, false, false, false); @@ -135,7 +135,7 @@ public static void bool3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_and_wide_wide() { bool3x3 a0 = bool3x3(false, false, true, true, false, false, true, true, true); @@ -183,7 +183,7 @@ public static void bool3x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_and_wide_scalar() { bool3x3 a0 = bool3x3(true, false, false, true, true, false, false, false, false); @@ -207,7 +207,7 @@ public static void bool3x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool3x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_or_wide_wide() { bool3x3 a0 = bool3x3(true, true, true, false, true, false, true, true, false); @@ -255,7 +255,7 @@ public static void bool3x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_or_wide_scalar() { bool3x3 a0 = bool3x3(true, true, false, true, true, true, true, false, true); @@ -279,7 +279,7 @@ public static void bool3x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool3x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_xor_wide_wide() { bool3x3 a0 = bool3x3(true, false, false, true, false, false, false, true, false); @@ -327,7 +327,7 @@ public static void bool3x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_xor_wide_scalar() { bool3x3 a0 = bool3x3(false, false, true, true, false, false, false, false, false); @@ -351,7 +351,7 @@ public static void bool3x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool3x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x3_operator_logical_not() { bool3x3 a0 = bool3x3(true, true, false, false, true, false, true, false, true); @@ -395,7 +395,7 @@ public static void bool3x3_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool3x3_EqualsObjectOverride() { TestUtils.IsFalse(new bool3x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool3x4.gen.cs b/src/Tests/Tests/Shared/TestBool3x4.gen.cs index c0981361..02565c51 100644 --- a/src/Tests/Tests/Shared/TestBool3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_equal_wide_wide() { bool3x4 a0 = bool3x4(true, false, true, false, false, true, false, false, true, false, true, false); @@ -39,7 +39,7 @@ public static void bool3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_equal_wide_scalar() { bool3x4 a0 = bool3x4(false, true, false, false, false, false, true, false, false, false, true, true); @@ -63,7 +63,7 @@ public static void bool3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_not_equal_wide_wide() { bool3x4 a0 = bool3x4(true, true, true, false, false, true, false, false, false, false, true, true); @@ -111,7 +111,7 @@ public static void bool3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_not_equal_wide_scalar() { bool3x4 a0 = bool3x4(false, true, false, true, true, false, false, false, false, false, false, false); @@ -135,7 +135,7 @@ public static void bool3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_and_wide_wide() { bool3x4 a0 = bool3x4(false, false, true, true, false, false, true, true, true, false, true, true); @@ -183,7 +183,7 @@ public static void bool3x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_and_wide_scalar() { bool3x4 a0 = bool3x4(true, false, false, true, true, false, false, false, false, false, true, true); @@ -207,7 +207,7 @@ public static void bool3x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool3x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_or_wide_wide() { bool3x4 a0 = bool3x4(true, true, true, false, true, false, true, true, false, true, true, true); @@ -255,7 +255,7 @@ public static void bool3x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_or_wide_scalar() { bool3x4 a0 = bool3x4(true, true, false, true, true, true, true, false, true, false, false, true); @@ -279,7 +279,7 @@ public static void bool3x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool3x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_xor_wide_wide() { bool3x4 a0 = bool3x4(true, false, false, true, false, false, false, true, false, false, true, true); @@ -327,7 +327,7 @@ public static void bool3x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_xor_wide_scalar() { bool3x4 a0 = bool3x4(false, false, true, true, false, false, false, false, false, false, false, true); @@ -351,7 +351,7 @@ public static void bool3x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool3x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3x4_operator_logical_not() { bool3x4 a0 = bool3x4(true, true, false, false, true, false, true, false, true, false, false, false); @@ -395,7 +395,7 @@ public static void bool3x4_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool3x4_EqualsObjectOverride() { TestUtils.IsFalse(new bool3x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool4.gen.cs b/src/Tests/Tests/Shared/TestBool4.gen.cs index 69e823ab..4faf4e36 100644 --- a/src/Tests/Tests/Shared/TestBool4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_constructor() { bool4 a = new bool4(false, true, false, true); @@ -25,7 +25,7 @@ public static void bool4_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_scalar_constructor() { bool4 a = new bool4(true); @@ -35,7 +35,7 @@ public static void bool4_scalar_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_static_constructor() { bool4 a = bool4(false, true, false, true); @@ -45,7 +45,7 @@ public static void bool4_static_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_static_scalar_constructor() { bool4 a = bool4(true); @@ -55,7 +55,7 @@ public static void bool4_static_scalar_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_equal_wide_wide() { bool4 a0 = bool4(true, false, true, false); @@ -79,7 +79,7 @@ public static void bool4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_equal_wide_scalar() { bool4 a0 = bool4(false, true, false, false); @@ -103,7 +103,7 @@ public static void bool4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_equal_scalar_wide() { bool a0 = (false); @@ -127,7 +127,7 @@ public static void bool4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_not_equal_wide_wide() { bool4 a0 = bool4(true, true, true, false); @@ -151,7 +151,7 @@ public static void bool4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_not_equal_wide_scalar() { bool4 a0 = bool4(false, true, false, true); @@ -175,7 +175,7 @@ public static void bool4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -199,7 +199,7 @@ public static void bool4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_and_wide_wide() { bool4 a0 = bool4(false, false, true, true); @@ -223,7 +223,7 @@ public static void bool4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_and_wide_scalar() { bool4 a0 = bool4(true, false, false, true); @@ -247,7 +247,7 @@ public static void bool4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -271,7 +271,7 @@ public static void bool4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_or_wide_wide() { bool4 a0 = bool4(true, true, true, false); @@ -295,7 +295,7 @@ public static void bool4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_or_wide_scalar() { bool4 a0 = bool4(true, true, false, true); @@ -319,7 +319,7 @@ public static void bool4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -343,7 +343,7 @@ public static void bool4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_xor_wide_wide() { bool4 a0 = bool4(true, false, false, true); @@ -367,7 +367,7 @@ public static void bool4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_xor_wide_scalar() { bool4 a0 = bool4(false, false, true, true); @@ -391,7 +391,7 @@ public static void bool4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -415,7 +415,7 @@ public static void bool4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_operator_logical_not() { bool4 a0 = bool4(true, true, false, false); @@ -435,7 +435,7 @@ public static void bool4_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool4_EqualsObjectOverride() { TestUtils.IsFalse(new bool4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool4x2.gen.cs b/src/Tests/Tests/Shared/TestBool4x2.gen.cs index 0a2a54ca..b7585d45 100644 --- a/src/Tests/Tests/Shared/TestBool4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_equal_wide_wide() { bool4x2 a0 = bool4x2(true, false, true, false, false, true, false, false); @@ -39,7 +39,7 @@ public static void bool4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_equal_wide_scalar() { bool4x2 a0 = bool4x2(false, true, false, false, false, false, true, false); @@ -63,7 +63,7 @@ public static void bool4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_not_equal_wide_wide() { bool4x2 a0 = bool4x2(true, true, true, false, false, true, false, false); @@ -111,7 +111,7 @@ public static void bool4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_not_equal_wide_scalar() { bool4x2 a0 = bool4x2(false, true, false, true, true, false, false, false); @@ -135,7 +135,7 @@ public static void bool4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_and_wide_wide() { bool4x2 a0 = bool4x2(false, false, true, true, false, false, true, true); @@ -183,7 +183,7 @@ public static void bool4x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_and_wide_scalar() { bool4x2 a0 = bool4x2(true, false, false, true, true, false, false, false); @@ -207,7 +207,7 @@ public static void bool4x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool4x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_or_wide_wide() { bool4x2 a0 = bool4x2(true, true, true, false, true, false, true, true); @@ -255,7 +255,7 @@ public static void bool4x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_or_wide_scalar() { bool4x2 a0 = bool4x2(true, true, false, true, true, true, true, false); @@ -279,7 +279,7 @@ public static void bool4x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool4x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_xor_wide_wide() { bool4x2 a0 = bool4x2(true, false, false, true, false, false, false, true); @@ -327,7 +327,7 @@ public static void bool4x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_xor_wide_scalar() { bool4x2 a0 = bool4x2(false, false, true, true, false, false, false, false); @@ -351,7 +351,7 @@ public static void bool4x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool4x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x2_operator_logical_not() { bool4x2 a0 = bool4x2(true, true, false, false, true, false, true, false); @@ -395,7 +395,7 @@ public static void bool4x2_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool4x2_EqualsObjectOverride() { TestUtils.IsFalse(new bool4x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool4x3.gen.cs b/src/Tests/Tests/Shared/TestBool4x3.gen.cs index 8be23641..012ad7e5 100644 --- a/src/Tests/Tests/Shared/TestBool4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_equal_wide_wide() { bool4x3 a0 = bool4x3(true, false, true, false, false, true, false, false, true, false, true, false); @@ -39,7 +39,7 @@ public static void bool4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_equal_wide_scalar() { bool4x3 a0 = bool4x3(false, true, false, false, false, false, true, false, false, false, true, true); @@ -63,7 +63,7 @@ public static void bool4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_not_equal_wide_wide() { bool4x3 a0 = bool4x3(true, true, true, false, false, true, false, false, false, false, true, true); @@ -111,7 +111,7 @@ public static void bool4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_not_equal_wide_scalar() { bool4x3 a0 = bool4x3(false, true, false, true, true, false, false, false, false, false, false, false); @@ -135,7 +135,7 @@ public static void bool4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_and_wide_wide() { bool4x3 a0 = bool4x3(false, false, true, true, false, false, true, true, true, false, true, true); @@ -183,7 +183,7 @@ public static void bool4x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_and_wide_scalar() { bool4x3 a0 = bool4x3(true, false, false, true, true, false, false, false, false, false, true, true); @@ -207,7 +207,7 @@ public static void bool4x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool4x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_or_wide_wide() { bool4x3 a0 = bool4x3(true, true, true, false, true, false, true, true, false, true, true, true); @@ -255,7 +255,7 @@ public static void bool4x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_or_wide_scalar() { bool4x3 a0 = bool4x3(true, true, false, true, true, true, true, false, true, false, false, true); @@ -279,7 +279,7 @@ public static void bool4x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool4x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_xor_wide_wide() { bool4x3 a0 = bool4x3(true, false, false, true, false, false, false, true, false, false, true, true); @@ -327,7 +327,7 @@ public static void bool4x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_xor_wide_scalar() { bool4x3 a0 = bool4x3(false, false, true, true, false, false, false, false, false, false, false, true); @@ -351,7 +351,7 @@ public static void bool4x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool4x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x3_operator_logical_not() { bool4x3 a0 = bool4x3(true, true, false, false, true, false, true, false, true, false, false, false); @@ -395,7 +395,7 @@ public static void bool4x3_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool4x3_EqualsObjectOverride() { TestUtils.IsFalse(new bool4x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestBool4x4.gen.cs b/src/Tests/Tests/Shared/TestBool4x4.gen.cs index c83c5d8d..9cb7e412 100644 --- a/src/Tests/Tests/Shared/TestBool4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_equal_wide_wide() { bool4x4 a0 = bool4x4(true, false, true, false, false, true, false, false, true, false, true, false, true, true, false, true); @@ -39,7 +39,7 @@ public static void bool4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_equal_wide_scalar() { bool4x4 a0 = bool4x4(false, true, false, false, false, false, true, false, false, false, true, true, false, true, false, true); @@ -63,7 +63,7 @@ public static void bool4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_not_equal_wide_wide() { bool4x4 a0 = bool4x4(true, true, true, false, false, true, false, false, false, false, true, true, true, true, true, true); @@ -111,7 +111,7 @@ public static void bool4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_not_equal_wide_scalar() { bool4x4 a0 = bool4x4(false, true, false, true, true, false, false, false, false, false, false, false, false, true, false, false); @@ -135,7 +135,7 @@ public static void bool4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_and_wide_wide() { bool4x4 a0 = bool4x4(false, false, true, true, false, false, true, true, true, false, true, true, true, true, false, false); @@ -183,7 +183,7 @@ public static void bool4x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_and_wide_scalar() { bool4x4 a0 = bool4x4(true, false, false, true, true, false, false, false, false, false, true, true, true, false, false, true); @@ -207,7 +207,7 @@ public static void bool4x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool4x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_or_wide_wide() { bool4x4 a0 = bool4x4(true, true, true, false, true, false, true, true, false, true, true, true, true, true, true, false); @@ -255,7 +255,7 @@ public static void bool4x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_or_wide_scalar() { bool4x4 a0 = bool4x4(true, true, false, true, true, true, true, false, true, false, false, true, false, false, true, false); @@ -279,7 +279,7 @@ public static void bool4x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool4x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_xor_wide_wide() { bool4x4 a0 = bool4x4(true, false, false, true, false, false, false, true, false, false, true, true, false, false, true, false); @@ -327,7 +327,7 @@ public static void bool4x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_xor_wide_scalar() { bool4x4 a0 = bool4x4(false, false, true, true, false, false, false, false, false, false, false, true, false, true, true, true); @@ -351,7 +351,7 @@ public static void bool4x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool4x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4x4_operator_logical_not() { bool4x4 a0 = bool4x4(true, true, false, false, true, false, true, false, true, false, false, false, false, true, true, false); @@ -395,7 +395,7 @@ public static void bool4x4_operator_logical_not() TestUtils.AreEqual(r3, !a3); } - [TestCase] + [TestCase /* For player builds */] public static void bool4x4_EqualsObjectOverride() { TestUtils.IsFalse(new bool4x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble2.gen.cs b/src/Tests/Tests/Shared/TestDouble2.gen.cs index cd44e120..30a3f849 100644 --- a/src/Tests/Tests/Shared/TestDouble2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_zero() { TestUtils.AreEqual(0.0, double2.zero.x); TestUtils.AreEqual(0.0, double2.zero.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_constructor() { double2 a = new double2(1, 2); @@ -30,7 +30,7 @@ public static void double2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_scalar_constructor() { double2 a = new double2(17.0); @@ -38,7 +38,7 @@ public static void double2_scalar_constructor() TestUtils.AreEqual(17.0, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_static_constructor() { double2 a = double2(1, 2); @@ -46,7 +46,7 @@ public static void double2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_static_scalar_constructor() { double2 a = double2(17.0); @@ -54,7 +54,7 @@ public static void double2_static_scalar_constructor() TestUtils.AreEqual(17.0, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_equal_wide_wide() { double2 a0 = double2(492.15758275061728, -495.20632027797694); @@ -78,7 +78,7 @@ public static void double2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_equal_wide_scalar() { double2 a0 = double2(-303.2300766926399, 451.52631327674089); @@ -102,7 +102,7 @@ public static void double2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -126,7 +126,7 @@ public static void double2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_not_equal_wide_wide() { double2 a0 = double2(430.8425316432689, 104.69001798736394); @@ -150,7 +150,7 @@ public static void double2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_not_equal_wide_scalar() { double2 a0 = double2(-16.914588697680529, 168.83411486858233); @@ -174,7 +174,7 @@ public static void double2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -198,7 +198,7 @@ public static void double2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_less_wide_wide() { double2 a0 = double2(196.84256825076534, 336.40979997087732); @@ -222,7 +222,7 @@ public static void double2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_less_wide_scalar() { double2 a0 = double2(-132.05731708000292, -192.46500477216438); @@ -246,7 +246,7 @@ public static void double2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -270,7 +270,7 @@ public static void double2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_greater_wide_wide() { double2 a0 = double2(483.50140141113729, 310.81563415695712); @@ -294,7 +294,7 @@ public static void double2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_greater_wide_scalar() { double2 a0 = double2(64.317918092160426, -397.70346445483318); @@ -318,7 +318,7 @@ public static void double2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -342,7 +342,7 @@ public static void double2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_less_equal_wide_wide() { double2 a0 = double2(-438.52313753521219, 210.48942837980087); @@ -366,7 +366,7 @@ public static void double2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_less_equal_wide_scalar() { double2 a0 = double2(193.4958237118534, 168.91555197952107); @@ -390,7 +390,7 @@ public static void double2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -414,7 +414,7 @@ public static void double2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_greater_equal_wide_wide() { double2 a0 = double2(-507.92858409692, 504.49748181947393); @@ -438,7 +438,7 @@ public static void double2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_greater_equal_wide_scalar() { double2 a0 = double2(465.15218732559686, -424.8860745024337); @@ -462,7 +462,7 @@ public static void double2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -486,7 +486,7 @@ public static void double2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_add_wide_wide() { double2 a0 = double2(506.12905263627374, -501.77980803967444); @@ -510,7 +510,7 @@ public static void double2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_add_wide_scalar() { double2 a0 = double2(-194.51420387742769, 338.54838696985894); @@ -534,7 +534,7 @@ public static void double2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -558,7 +558,7 @@ public static void double2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_sub_wide_wide() { double2 a0 = double2(160.4922617229131, 11.223957305412682); @@ -582,7 +582,7 @@ public static void double2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_sub_wide_scalar() { double2 a0 = double2(207.38960108877609, 248.45773684627272); @@ -606,7 +606,7 @@ public static void double2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -630,7 +630,7 @@ public static void double2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_mul_wide_wide() { double2 a0 = double2(-482.71381710596097, -407.29348559272171); @@ -654,7 +654,7 @@ public static void double2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_mul_wide_scalar() { double2 a0 = double2(-96.318821236639678, -277.14229239017811); @@ -678,7 +678,7 @@ public static void double2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -702,7 +702,7 @@ public static void double2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_div_wide_wide() { double2 a0 = double2(-353.13144390337703, -102.79985456485292); @@ -726,7 +726,7 @@ public static void double2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_div_wide_scalar() { double2 a0 = double2(171.34242184988341, 0.10338377957384637); @@ -750,7 +750,7 @@ public static void double2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -774,7 +774,7 @@ public static void double2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_mod_wide_wide() { double2 a0 = double2(-388.81249422059045, 181.68118842955732); @@ -798,7 +798,7 @@ public static void double2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_mod_wide_scalar() { double2 a0 = double2(-244.49962889612635, -211.81931958525411); @@ -822,7 +822,7 @@ public static void double2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -846,7 +846,7 @@ public static void double2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_plus() { double2 a0 = double2(-418.82956357432045, -405.79894823851015); @@ -866,7 +866,7 @@ public static void double2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_neg() { double2 a0 = double2(148.46174890755753, -467.12267873581624); @@ -886,7 +886,7 @@ public static void double2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_prefix_inc() { double2 a0 = double2(-139.84208137348389, -56.743654039103376); @@ -906,7 +906,7 @@ public static void double2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_postfix_inc() { double2 a0 = double2(-396.6697396695007, 511.20749378167443); @@ -926,7 +926,7 @@ public static void double2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_prefix_dec() { double2 a0 = double2(123.12869626056806, 256.8437465433235); @@ -946,7 +946,7 @@ public static void double2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_operator_postfix_dec() { double2 a0 = double2(379.68831723727669, 302.69287814884115); @@ -966,7 +966,7 @@ public static void double2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_shuffle_result_1() { double2 a = double2(0, 1); @@ -978,7 +978,7 @@ public static void double2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_shuffle_result_2() { double2 a = double2(0, 1); @@ -1002,7 +1002,7 @@ public static void double2_shuffle_result_2() TestUtils.AreEqual(double2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_shuffle_result_3() { double2 a = double2(0, 1); @@ -1026,7 +1026,7 @@ public static void double2_shuffle_result_3() TestUtils.AreEqual(double3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_shuffle_result_4() { double2 a = double2(0, 1); @@ -1050,7 +1050,7 @@ public static void double2_shuffle_result_4() TestUtils.AreEqual(double4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX)); } - [TestCase] + [TestCase /* For player builds */] public static void double2_EqualsObjectOverride() { TestUtils.IsFalse(new double2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs index c7fc90d5..5531de5f 100644 --- a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_zero() { TestUtils.AreEqual(0.0, double2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void double2x2_zero() TestUtils.AreEqual(0.0, double2x2.zero.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_identity() { TestUtils.AreEqual(1.0, double2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void double2x2_identity() TestUtils.AreEqual(1.0, double2x2.identity.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_equal_wide_wide() { double2x2 a0 = double2x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182); @@ -57,7 +57,7 @@ public static void double2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_equal_wide_scalar() { double2x2 a0 = double2x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995); @@ -81,7 +81,7 @@ public static void double2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -105,7 +105,7 @@ public static void double2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_not_equal_wide_wide() { double2x2 a0 = double2x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048); @@ -129,7 +129,7 @@ public static void double2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_not_equal_wide_scalar() { double2x2 a0 = double2x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137); @@ -153,7 +153,7 @@ public static void double2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -177,7 +177,7 @@ public static void double2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_less_wide_wide() { double2x2 a0 = double2x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963); @@ -201,7 +201,7 @@ public static void double2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_less_wide_scalar() { double2x2 a0 = double2x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561); @@ -225,7 +225,7 @@ public static void double2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -249,7 +249,7 @@ public static void double2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_greater_wide_wide() { double2x2 a0 = double2x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671); @@ -273,7 +273,7 @@ public static void double2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_greater_wide_scalar() { double2x2 a0 = double2x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157); @@ -297,7 +297,7 @@ public static void double2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -321,7 +321,7 @@ public static void double2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_less_equal_wide_wide() { double2x2 a0 = double2x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857); @@ -345,7 +345,7 @@ public static void double2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_less_equal_wide_scalar() { double2x2 a0 = double2x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292); @@ -369,7 +369,7 @@ public static void double2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -393,7 +393,7 @@ public static void double2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_greater_equal_wide_wide() { double2x2 a0 = double2x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784); @@ -417,7 +417,7 @@ public static void double2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_greater_equal_wide_scalar() { double2x2 a0 = double2x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356); @@ -441,7 +441,7 @@ public static void double2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -465,7 +465,7 @@ public static void double2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_add_wide_wide() { double2x2 a0 = double2x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274); @@ -489,7 +489,7 @@ public static void double2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_add_wide_scalar() { double2x2 a0 = double2x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752); @@ -513,7 +513,7 @@ public static void double2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -537,7 +537,7 @@ public static void double2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_sub_wide_wide() { double2x2 a0 = double2x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311); @@ -561,7 +561,7 @@ public static void double2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_sub_wide_scalar() { double2x2 a0 = double2x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506); @@ -585,7 +585,7 @@ public static void double2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -609,7 +609,7 @@ public static void double2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_mul_wide_wide() { double2x2 a0 = double2x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182); @@ -633,7 +633,7 @@ public static void double2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_mul_wide_scalar() { double2x2 a0 = double2x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409); @@ -657,7 +657,7 @@ public static void double2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -681,7 +681,7 @@ public static void double2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_div_wide_wide() { double2x2 a0 = double2x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176); @@ -705,7 +705,7 @@ public static void double2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_div_wide_scalar() { double2x2 a0 = double2x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078); @@ -729,7 +729,7 @@ public static void double2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -753,7 +753,7 @@ public static void double2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_mod_wide_wide() { double2x2 a0 = double2x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813); @@ -777,7 +777,7 @@ public static void double2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_mod_wide_scalar() { double2x2 a0 = double2x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672); @@ -801,7 +801,7 @@ public static void double2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -825,7 +825,7 @@ public static void double2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_plus() { double2x2 a0 = double2x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421); @@ -845,7 +845,7 @@ public static void double2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_neg() { double2x2 a0 = double2x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463); @@ -865,7 +865,7 @@ public static void double2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_prefix_inc() { double2x2 a0 = double2x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962); @@ -885,7 +885,7 @@ public static void double2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_postfix_inc() { double2x2 a0 = double2x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153); @@ -905,7 +905,7 @@ public static void double2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_prefix_dec() { double2x2 a0 = double2x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563); @@ -925,7 +925,7 @@ public static void double2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x2_operator_postfix_dec() { double2x2 a0 = double2x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962); @@ -945,7 +945,7 @@ public static void double2x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double2x2_EqualsObjectOverride() { TestUtils.IsFalse(new double2x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs index d95bba8d..20df3853 100644 --- a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_zero() { TestUtils.AreEqual(0.0, double2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void double2x3_zero() TestUtils.AreEqual(0.0, double2x3.zero.c2.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_equal_wide_wide() { double2x3 a0 = double2x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749); @@ -50,7 +50,7 @@ public static void double2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_equal_wide_scalar() { double2x3 a0 = double2x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315); @@ -74,7 +74,7 @@ public static void double2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -98,7 +98,7 @@ public static void double2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_not_equal_wide_wide() { double2x3 a0 = double2x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379); @@ -122,7 +122,7 @@ public static void double2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_not_equal_wide_scalar() { double2x3 a0 = double2x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959); @@ -146,7 +146,7 @@ public static void double2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -170,7 +170,7 @@ public static void double2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_less_wide_wide() { double2x3 a0 = double2x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774); @@ -194,7 +194,7 @@ public static void double2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_less_wide_scalar() { double2x3 a0 = double2x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879); @@ -218,7 +218,7 @@ public static void double2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -242,7 +242,7 @@ public static void double2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_greater_wide_wide() { double2x3 a0 = double2x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479); @@ -266,7 +266,7 @@ public static void double2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_greater_wide_scalar() { double2x3 a0 = double2x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809); @@ -290,7 +290,7 @@ public static void double2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -314,7 +314,7 @@ public static void double2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_less_equal_wide_wide() { double2x3 a0 = double2x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475); @@ -338,7 +338,7 @@ public static void double2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_less_equal_wide_scalar() { double2x3 a0 = double2x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136); @@ -362,7 +362,7 @@ public static void double2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -386,7 +386,7 @@ public static void double2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_greater_equal_wide_wide() { double2x3 a0 = double2x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193); @@ -410,7 +410,7 @@ public static void double2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_greater_equal_wide_scalar() { double2x3 a0 = double2x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976); @@ -434,7 +434,7 @@ public static void double2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -458,7 +458,7 @@ public static void double2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_add_wide_wide() { double2x3 a0 = double2x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056); @@ -482,7 +482,7 @@ public static void double2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_add_wide_scalar() { double2x3 a0 = double2x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166); @@ -506,7 +506,7 @@ public static void double2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -530,7 +530,7 @@ public static void double2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_sub_wide_wide() { double2x3 a0 = double2x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053); @@ -554,7 +554,7 @@ public static void double2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_sub_wide_scalar() { double2x3 a0 = double2x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896); @@ -578,7 +578,7 @@ public static void double2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -602,7 +602,7 @@ public static void double2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_mul_wide_wide() { double2x3 a0 = double2x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747); @@ -626,7 +626,7 @@ public static void double2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_mul_wide_scalar() { double2x3 a0 = double2x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229); @@ -650,7 +650,7 @@ public static void double2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -674,7 +674,7 @@ public static void double2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_div_wide_wide() { double2x3 a0 = double2x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758); @@ -698,7 +698,7 @@ public static void double2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_div_wide_scalar() { double2x3 a0 = double2x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509); @@ -722,7 +722,7 @@ public static void double2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -746,7 +746,7 @@ public static void double2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_mod_wide_wide() { double2x3 a0 = double2x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406); @@ -770,7 +770,7 @@ public static void double2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_mod_wide_scalar() { double2x3 a0 = double2x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221); @@ -794,7 +794,7 @@ public static void double2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -818,7 +818,7 @@ public static void double2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_plus() { double2x3 a0 = double2x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287); @@ -838,7 +838,7 @@ public static void double2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_neg() { double2x3 a0 = double2x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605); @@ -858,7 +858,7 @@ public static void double2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_prefix_inc() { double2x3 a0 = double2x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198); @@ -878,7 +878,7 @@ public static void double2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_postfix_inc() { double2x3 a0 = double2x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219); @@ -898,7 +898,7 @@ public static void double2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_prefix_dec() { double2x3 a0 = double2x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339); @@ -918,7 +918,7 @@ public static void double2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x3_operator_postfix_dec() { double2x3 a0 = double2x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231); @@ -938,7 +938,7 @@ public static void double2x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double2x3_EqualsObjectOverride() { TestUtils.IsFalse(new double2x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs index aac05afe..822a43bb 100644 --- a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_zero() { TestUtils.AreEqual(0.0, double2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void double2x4_zero() TestUtils.AreEqual(0.0, double2x4.zero.c3.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_equal_wide_wide() { double2x4 a0 = double2x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889); @@ -52,7 +52,7 @@ public static void double2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_equal_wide_scalar() { double2x4 a0 = double2x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405); @@ -76,7 +76,7 @@ public static void double2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -100,7 +100,7 @@ public static void double2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_not_equal_wide_wide() { double2x4 a0 = double2x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895); @@ -124,7 +124,7 @@ public static void double2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_not_equal_wide_scalar() { double2x4 a0 = double2x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842); @@ -148,7 +148,7 @@ public static void double2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -172,7 +172,7 @@ public static void double2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_less_wide_wide() { double2x4 a0 = double2x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259); @@ -196,7 +196,7 @@ public static void double2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_less_wide_scalar() { double2x4 a0 = double2x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061); @@ -220,7 +220,7 @@ public static void double2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -244,7 +244,7 @@ public static void double2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_greater_wide_wide() { double2x4 a0 = double2x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484); @@ -268,7 +268,7 @@ public static void double2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_greater_wide_scalar() { double2x4 a0 = double2x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972); @@ -292,7 +292,7 @@ public static void double2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -316,7 +316,7 @@ public static void double2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_less_equal_wide_wide() { double2x4 a0 = double2x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232); @@ -340,7 +340,7 @@ public static void double2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_less_equal_wide_scalar() { double2x4 a0 = double2x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582); @@ -364,7 +364,7 @@ public static void double2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -388,7 +388,7 @@ public static void double2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_greater_equal_wide_wide() { double2x4 a0 = double2x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265); @@ -412,7 +412,7 @@ public static void double2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_greater_equal_wide_scalar() { double2x4 a0 = double2x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838); @@ -436,7 +436,7 @@ public static void double2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -460,7 +460,7 @@ public static void double2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_add_wide_wide() { double2x4 a0 = double2x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656); @@ -484,7 +484,7 @@ public static void double2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_add_wide_scalar() { double2x4 a0 = double2x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454); @@ -508,7 +508,7 @@ public static void double2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -532,7 +532,7 @@ public static void double2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_sub_wide_wide() { double2x4 a0 = double2x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537); @@ -556,7 +556,7 @@ public static void double2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_sub_wide_scalar() { double2x4 a0 = double2x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965); @@ -580,7 +580,7 @@ public static void double2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -604,7 +604,7 @@ public static void double2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_mul_wide_wide() { double2x4 a0 = double2x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149); @@ -628,7 +628,7 @@ public static void double2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_mul_wide_scalar() { double2x4 a0 = double2x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334); @@ -652,7 +652,7 @@ public static void double2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -676,7 +676,7 @@ public static void double2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_div_wide_wide() { double2x4 a0 = double2x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537); @@ -700,7 +700,7 @@ public static void double2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_div_wide_scalar() { double2x4 a0 = double2x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539); @@ -724,7 +724,7 @@ public static void double2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -748,7 +748,7 @@ public static void double2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_mod_wide_wide() { double2x4 a0 = double2x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664); @@ -772,7 +772,7 @@ public static void double2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_mod_wide_scalar() { double2x4 a0 = double2x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243); @@ -796,7 +796,7 @@ public static void double2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -820,7 +820,7 @@ public static void double2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_plus() { double2x4 a0 = double2x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488); @@ -840,7 +840,7 @@ public static void double2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_neg() { double2x4 a0 = double2x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581); @@ -860,7 +860,7 @@ public static void double2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_prefix_inc() { double2x4 a0 = double2x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267); @@ -880,7 +880,7 @@ public static void double2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_postfix_inc() { double2x4 a0 = double2x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271); @@ -900,7 +900,7 @@ public static void double2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_prefix_dec() { double2x4 a0 = double2x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558); @@ -920,7 +920,7 @@ public static void double2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2x4_operator_postfix_dec() { double2x4 a0 = double2x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568); @@ -940,7 +940,7 @@ public static void double2x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double2x4_EqualsObjectOverride() { TestUtils.IsFalse(new double2x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble3.gen.cs b/src/Tests/Tests/Shared/TestDouble3.gen.cs index cc53ddbf..2bd08a5d 100644 --- a/src/Tests/Tests/Shared/TestDouble3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_zero() { TestUtils.AreEqual(0.0, double3.zero.x); @@ -23,7 +23,7 @@ public static void double3_zero() TestUtils.AreEqual(0.0, double3.zero.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_constructor() { double3 a = new double3(1, 2, 3); @@ -32,7 +32,7 @@ public static void double3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_scalar_constructor() { double3 a = new double3(17.0); @@ -41,7 +41,7 @@ public static void double3_scalar_constructor() TestUtils.AreEqual(17.0, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_static_constructor() { double3 a = double3(1, 2, 3); @@ -50,7 +50,7 @@ public static void double3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_static_scalar_constructor() { double3 a = double3(17.0); @@ -59,7 +59,7 @@ public static void double3_static_scalar_constructor() TestUtils.AreEqual(17.0, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_equal_wide_wide() { double3 a0 = double3(492.15758275061728, -495.20632027797694, 227.45765195947968); @@ -83,7 +83,7 @@ public static void double3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_equal_wide_scalar() { double3 a0 = double3(-303.2300766926399, 451.52631327674089, -253.65587413201848); @@ -107,7 +107,7 @@ public static void double3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -131,7 +131,7 @@ public static void double3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_not_equal_wide_wide() { double3 a0 = double3(430.8425316432689, 104.69001798736394, 225.80243478799355); @@ -155,7 +155,7 @@ public static void double3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_not_equal_wide_scalar() { double3 a0 = double3(-16.914588697680529, 168.83411486858233, -462.71352145760949); @@ -179,7 +179,7 @@ public static void double3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -203,7 +203,7 @@ public static void double3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_less_wide_wide() { double3 a0 = double3(196.84256825076534, 336.40979997087732, 251.96372115424072); @@ -227,7 +227,7 @@ public static void double3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_less_wide_scalar() { double3 a0 = double3(-132.05731708000292, -192.46500477216438, -66.834607870706634); @@ -251,7 +251,7 @@ public static void double3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -275,7 +275,7 @@ public static void double3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_greater_wide_wide() { double3 a0 = double3(483.50140141113729, 310.81563415695712, 106.9661896726891); @@ -299,7 +299,7 @@ public static void double3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_greater_wide_scalar() { double3 a0 = double3(64.317918092160426, -397.70346445483318, 431.87690826499693); @@ -323,7 +323,7 @@ public static void double3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -347,7 +347,7 @@ public static void double3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_less_equal_wide_wide() { double3 a0 = double3(-438.52313753521219, 210.48942837980087, 4.8773329280677444); @@ -371,7 +371,7 @@ public static void double3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_less_equal_wide_scalar() { double3 a0 = double3(193.4958237118534, 168.91555197952107, -313.9930695565385); @@ -395,7 +395,7 @@ public static void double3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -419,7 +419,7 @@ public static void double3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_greater_equal_wide_wide() { double3 a0 = double3(-507.92858409692, 504.49748181947393, -385.43449205226938); @@ -443,7 +443,7 @@ public static void double3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_greater_equal_wide_scalar() { double3 a0 = double3(465.15218732559686, -424.8860745024337, -209.22109685150025); @@ -467,7 +467,7 @@ public static void double3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -491,7 +491,7 @@ public static void double3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_add_wide_wide() { double3 a0 = double3(506.12905263627374, -501.77980803967444, 420.08479638587903); @@ -515,7 +515,7 @@ public static void double3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_add_wide_scalar() { double3 a0 = double3(-194.51420387742769, 338.54838696985894, 246.97140252169754); @@ -539,7 +539,7 @@ public static void double3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -563,7 +563,7 @@ public static void double3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_sub_wide_wide() { double3 a0 = double3(160.4922617229131, 11.223957305412682, 359.20010607279846); @@ -587,7 +587,7 @@ public static void double3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_sub_wide_scalar() { double3 a0 = double3(207.38960108877609, 248.45773684627272, -384.82393211164697); @@ -611,7 +611,7 @@ public static void double3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -635,7 +635,7 @@ public static void double3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_mul_wide_wide() { double3 a0 = double3(-482.71381710596097, -407.29348559272171, 137.70058995937029); @@ -659,7 +659,7 @@ public static void double3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_mul_wide_scalar() { double3 a0 = double3(-96.318821236639678, -277.14229239017811, -239.93690191951436); @@ -683,7 +683,7 @@ public static void double3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -707,7 +707,7 @@ public static void double3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_div_wide_wide() { double3 a0 = double3(-353.13144390337703, -102.79985456485292, 51.319128298814917); @@ -731,7 +731,7 @@ public static void double3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_div_wide_scalar() { double3 a0 = double3(171.34242184988341, 0.10338377957384637, 57.888263967767443); @@ -755,7 +755,7 @@ public static void double3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -779,7 +779,7 @@ public static void double3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_mod_wide_wide() { double3 a0 = double3(-388.81249422059045, 181.68118842955732, -167.07872470052854); @@ -803,7 +803,7 @@ public static void double3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_mod_wide_scalar() { double3 a0 = double3(-244.49962889612635, -211.81931958525411, -145.92677576184587); @@ -827,7 +827,7 @@ public static void double3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -851,7 +851,7 @@ public static void double3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_plus() { double3 a0 = double3(-418.82956357432045, -405.79894823851015, -34.041791216489742); @@ -871,7 +871,7 @@ public static void double3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_neg() { double3 a0 = double3(148.46174890755753, -467.12267873581624, 132.04719954917539); @@ -891,7 +891,7 @@ public static void double3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_prefix_inc() { double3 a0 = double3(-139.84208137348389, -56.743654039103376, -381.955324589254); @@ -911,7 +911,7 @@ public static void double3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_postfix_inc() { double3 a0 = double3(-396.6697396695007, 511.20749378167443, 249.11127030528678); @@ -931,7 +931,7 @@ public static void double3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_prefix_dec() { double3 a0 = double3(123.12869626056806, 256.8437465433235, 156.33078844674435); @@ -951,7 +951,7 @@ public static void double3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_operator_postfix_dec() { double3 a0 = double3(379.68831723727669, 302.69287814884115, -176.07134040448409); @@ -971,7 +971,7 @@ public static void double3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_shuffle_result_1() { double3 a = double3(0, 1, 2); @@ -985,7 +985,7 @@ public static void double3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_shuffle_result_2() { double3 a = double3(0, 1, 2); @@ -1009,7 +1009,7 @@ public static void double3_shuffle_result_2() TestUtils.AreEqual(double2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_shuffle_result_3() { double3 a = double3(0, 1, 2); @@ -1033,7 +1033,7 @@ public static void double3_shuffle_result_3() TestUtils.AreEqual(double3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_shuffle_result_4() { double3 a = double3(0, 1, 2); @@ -1057,7 +1057,7 @@ public static void double3_shuffle_result_4() TestUtils.AreEqual(double4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void double3_EqualsObjectOverride() { TestUtils.IsFalse(new double3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs index 382e68b6..bbfffa3a 100644 --- a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_zero() { TestUtils.AreEqual(0.0, double3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void double3x2_zero() TestUtils.AreEqual(0.0, double3x2.zero.c1.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_equal_wide_wide() { double3x2 a0 = double3x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749); @@ -50,7 +50,7 @@ public static void double3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_equal_wide_scalar() { double3x2 a0 = double3x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315); @@ -74,7 +74,7 @@ public static void double3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -98,7 +98,7 @@ public static void double3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_not_equal_wide_wide() { double3x2 a0 = double3x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379); @@ -122,7 +122,7 @@ public static void double3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_not_equal_wide_scalar() { double3x2 a0 = double3x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959); @@ -146,7 +146,7 @@ public static void double3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -170,7 +170,7 @@ public static void double3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_less_wide_wide() { double3x2 a0 = double3x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774); @@ -194,7 +194,7 @@ public static void double3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_less_wide_scalar() { double3x2 a0 = double3x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879); @@ -218,7 +218,7 @@ public static void double3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -242,7 +242,7 @@ public static void double3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_greater_wide_wide() { double3x2 a0 = double3x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479); @@ -266,7 +266,7 @@ public static void double3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_greater_wide_scalar() { double3x2 a0 = double3x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809); @@ -290,7 +290,7 @@ public static void double3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -314,7 +314,7 @@ public static void double3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_less_equal_wide_wide() { double3x2 a0 = double3x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475); @@ -338,7 +338,7 @@ public static void double3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_less_equal_wide_scalar() { double3x2 a0 = double3x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136); @@ -362,7 +362,7 @@ public static void double3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -386,7 +386,7 @@ public static void double3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_greater_equal_wide_wide() { double3x2 a0 = double3x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193); @@ -410,7 +410,7 @@ public static void double3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_greater_equal_wide_scalar() { double3x2 a0 = double3x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976); @@ -434,7 +434,7 @@ public static void double3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -458,7 +458,7 @@ public static void double3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_add_wide_wide() { double3x2 a0 = double3x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056); @@ -482,7 +482,7 @@ public static void double3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_add_wide_scalar() { double3x2 a0 = double3x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166); @@ -506,7 +506,7 @@ public static void double3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -530,7 +530,7 @@ public static void double3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_sub_wide_wide() { double3x2 a0 = double3x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053); @@ -554,7 +554,7 @@ public static void double3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_sub_wide_scalar() { double3x2 a0 = double3x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896); @@ -578,7 +578,7 @@ public static void double3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -602,7 +602,7 @@ public static void double3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_mul_wide_wide() { double3x2 a0 = double3x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747); @@ -626,7 +626,7 @@ public static void double3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_mul_wide_scalar() { double3x2 a0 = double3x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229); @@ -650,7 +650,7 @@ public static void double3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -674,7 +674,7 @@ public static void double3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_div_wide_wide() { double3x2 a0 = double3x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758); @@ -698,7 +698,7 @@ public static void double3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_div_wide_scalar() { double3x2 a0 = double3x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509); @@ -722,7 +722,7 @@ public static void double3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -746,7 +746,7 @@ public static void double3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_mod_wide_wide() { double3x2 a0 = double3x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406); @@ -770,7 +770,7 @@ public static void double3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_mod_wide_scalar() { double3x2 a0 = double3x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221); @@ -794,7 +794,7 @@ public static void double3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -818,7 +818,7 @@ public static void double3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_plus() { double3x2 a0 = double3x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287); @@ -838,7 +838,7 @@ public static void double3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_neg() { double3x2 a0 = double3x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605); @@ -858,7 +858,7 @@ public static void double3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_prefix_inc() { double3x2 a0 = double3x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198); @@ -878,7 +878,7 @@ public static void double3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_postfix_inc() { double3x2 a0 = double3x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219); @@ -898,7 +898,7 @@ public static void double3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_prefix_dec() { double3x2 a0 = double3x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339); @@ -918,7 +918,7 @@ public static void double3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x2_operator_postfix_dec() { double3x2 a0 = double3x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231); @@ -938,7 +938,7 @@ public static void double3x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double3x2_EqualsObjectOverride() { TestUtils.IsFalse(new double3x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs index 56364618..aca1ba86 100644 --- a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_zero() { TestUtils.AreEqual(0.0, double3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void double3x3_zero() TestUtils.AreEqual(0.0, double3x3.zero.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_identity() { TestUtils.AreEqual(1.0, double3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void double3x3_identity() TestUtils.AreEqual(1.0, double3x3.identity.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_equal_wide_wide() { double3x3 a0 = double3x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655); @@ -67,7 +67,7 @@ public static void double3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_equal_wide_scalar() { double3x3 a0 = double3x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386); @@ -91,7 +91,7 @@ public static void double3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -115,7 +115,7 @@ public static void double3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_not_equal_wide_wide() { double3x3 a0 = double3x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975); @@ -139,7 +139,7 @@ public static void double3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_not_equal_wide_scalar() { double3x3 a0 = double3x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783); @@ -163,7 +163,7 @@ public static void double3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -187,7 +187,7 @@ public static void double3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_less_wide_wide() { double3x3 a0 = double3x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472); @@ -211,7 +211,7 @@ public static void double3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_less_wide_scalar() { double3x3 a0 = double3x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772); @@ -235,7 +235,7 @@ public static void double3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -259,7 +259,7 @@ public static void double3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_greater_wide_wide() { double3x3 a0 = double3x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417); @@ -283,7 +283,7 @@ public static void double3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_greater_wide_scalar() { double3x3 a0 = double3x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148); @@ -307,7 +307,7 @@ public static void double3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -331,7 +331,7 @@ public static void double3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_less_equal_wide_wide() { double3x3 a0 = double3x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323); @@ -355,7 +355,7 @@ public static void double3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_less_equal_wide_scalar() { double3x3 a0 = double3x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203); @@ -379,7 +379,7 @@ public static void double3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -403,7 +403,7 @@ public static void double3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_greater_equal_wide_wide() { double3x3 a0 = double3x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094); @@ -427,7 +427,7 @@ public static void double3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_greater_equal_wide_scalar() { double3x3 a0 = double3x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562); @@ -451,7 +451,7 @@ public static void double3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -475,7 +475,7 @@ public static void double3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_add_wide_wide() { double3x3 a0 = double3x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012); @@ -499,7 +499,7 @@ public static void double3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_add_wide_scalar() { double3x3 a0 = double3x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084); @@ -523,7 +523,7 @@ public static void double3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -547,7 +547,7 @@ public static void double3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_sub_wide_wide() { double3x3 a0 = double3x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693); @@ -571,7 +571,7 @@ public static void double3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_sub_wide_scalar() { double3x3 a0 = double3x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796); @@ -595,7 +595,7 @@ public static void double3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -619,7 +619,7 @@ public static void double3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_mul_wide_wide() { double3x3 a0 = double3x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114); @@ -643,7 +643,7 @@ public static void double3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_mul_wide_scalar() { double3x3 a0 = double3x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419); @@ -667,7 +667,7 @@ public static void double3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -691,7 +691,7 @@ public static void double3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_div_wide_wide() { double3x3 a0 = double3x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105); @@ -715,7 +715,7 @@ public static void double3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_div_wide_scalar() { double3x3 a0 = double3x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234); @@ -739,7 +739,7 @@ public static void double3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -763,7 +763,7 @@ public static void double3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_mod_wide_wide() { double3x3 a0 = double3x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616); @@ -787,7 +787,7 @@ public static void double3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_mod_wide_scalar() { double3x3 a0 = double3x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039); @@ -811,7 +811,7 @@ public static void double3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -835,7 +835,7 @@ public static void double3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_plus() { double3x3 a0 = double3x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803); @@ -855,7 +855,7 @@ public static void double3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_neg() { double3x3 a0 = double3x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887); @@ -875,7 +875,7 @@ public static void double3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_prefix_inc() { double3x3 a0 = double3x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068); @@ -895,7 +895,7 @@ public static void double3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_postfix_inc() { double3x3 a0 = double3x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894); @@ -915,7 +915,7 @@ public static void double3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_prefix_dec() { double3x3 a0 = double3x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851); @@ -935,7 +935,7 @@ public static void double3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x3_operator_postfix_dec() { double3x3 a0 = double3x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415); @@ -955,7 +955,7 @@ public static void double3x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double3x3_EqualsObjectOverride() { TestUtils.IsFalse(new double3x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs index c54ef5be..48170ecf 100644 --- a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_zero() { TestUtils.AreEqual(0.0, double3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void double3x4_zero() TestUtils.AreEqual(0.0, double3x4.zero.c3.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_equal_wide_wide() { double3x4 a0 = double3x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078); @@ -56,7 +56,7 @@ public static void double3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_equal_wide_scalar() { double3x4 a0 = double3x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978); @@ -80,7 +80,7 @@ public static void double3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -104,7 +104,7 @@ public static void double3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_not_equal_wide_wide() { double3x4 a0 = double3x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394); @@ -128,7 +128,7 @@ public static void double3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_not_equal_wide_scalar() { double3x4 a0 = double3x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992); @@ -152,7 +152,7 @@ public static void double3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -176,7 +176,7 @@ public static void double3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_less_wide_wide() { double3x4 a0 = double3x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725); @@ -200,7 +200,7 @@ public static void double3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_less_wide_scalar() { double3x4 a0 = double3x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562); @@ -224,7 +224,7 @@ public static void double3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -248,7 +248,7 @@ public static void double3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_greater_wide_wide() { double3x4 a0 = double3x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906); @@ -272,7 +272,7 @@ public static void double3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_greater_wide_scalar() { double3x4 a0 = double3x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745); @@ -296,7 +296,7 @@ public static void double3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -320,7 +320,7 @@ public static void double3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_less_equal_wide_wide() { double3x4 a0 = double3x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363); @@ -344,7 +344,7 @@ public static void double3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_less_equal_wide_scalar() { double3x4 a0 = double3x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836); @@ -368,7 +368,7 @@ public static void double3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -392,7 +392,7 @@ public static void double3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_greater_equal_wide_wide() { double3x4 a0 = double3x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473); @@ -416,7 +416,7 @@ public static void double3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_greater_equal_wide_scalar() { double3x4 a0 = double3x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435); @@ -440,7 +440,7 @@ public static void double3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -464,7 +464,7 @@ public static void double3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_add_wide_wide() { double3x4 a0 = double3x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627); @@ -488,7 +488,7 @@ public static void double3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_add_wide_scalar() { double3x4 a0 = double3x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649); @@ -512,7 +512,7 @@ public static void double3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -536,7 +536,7 @@ public static void double3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_sub_wide_wide() { double3x4 a0 = double3x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149); @@ -560,7 +560,7 @@ public static void double3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_sub_wide_scalar() { double3x4 a0 = double3x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335); @@ -584,7 +584,7 @@ public static void double3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -608,7 +608,7 @@ public static void double3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_mul_wide_wide() { double3x4 a0 = double3x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408); @@ -632,7 +632,7 @@ public static void double3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_mul_wide_scalar() { double3x4 a0 = double3x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186); @@ -656,7 +656,7 @@ public static void double3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -680,7 +680,7 @@ public static void double3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_div_wide_wide() { double3x4 a0 = double3x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039); @@ -704,7 +704,7 @@ public static void double3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_div_wide_scalar() { double3x4 a0 = double3x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787); @@ -728,7 +728,7 @@ public static void double3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -752,7 +752,7 @@ public static void double3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_mod_wide_wide() { double3x4 a0 = double3x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538); @@ -776,7 +776,7 @@ public static void double3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_mod_wide_scalar() { double3x4 a0 = double3x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423); @@ -800,7 +800,7 @@ public static void double3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -824,7 +824,7 @@ public static void double3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_plus() { double3x4 a0 = double3x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724); @@ -844,7 +844,7 @@ public static void double3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_neg() { double3x4 a0 = double3x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852); @@ -864,7 +864,7 @@ public static void double3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_prefix_inc() { double3x4 a0 = double3x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212); @@ -884,7 +884,7 @@ public static void double3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_postfix_inc() { double3x4 a0 = double3x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185); @@ -904,7 +904,7 @@ public static void double3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_prefix_dec() { double3x4 a0 = double3x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956); @@ -924,7 +924,7 @@ public static void double3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3x4_operator_postfix_dec() { double3x4 a0 = double3x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677); @@ -944,7 +944,7 @@ public static void double3x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double3x4_EqualsObjectOverride() { TestUtils.IsFalse(new double3x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble4.gen.cs b/src/Tests/Tests/Shared/TestDouble4.gen.cs index 2d907e2a..6dec9e23 100644 --- a/src/Tests/Tests/Shared/TestDouble4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_zero() { TestUtils.AreEqual(0.0, double4.zero.x); @@ -24,7 +24,7 @@ public static void double4_zero() TestUtils.AreEqual(0.0, double4.zero.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_constructor() { double4 a = new double4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void double4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_scalar_constructor() { double4 a = new double4(17.0); @@ -44,7 +44,7 @@ public static void double4_scalar_constructor() TestUtils.AreEqual(17.0, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_static_constructor() { double4 a = double4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void double4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_static_scalar_constructor() { double4 a = double4(17.0); @@ -64,7 +64,7 @@ public static void double4_static_scalar_constructor() TestUtils.AreEqual(17.0, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_equal_wide_wide() { double4 a0 = double4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182); @@ -88,7 +88,7 @@ public static void double4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_equal_wide_scalar() { double4 a0 = double4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995); @@ -112,7 +112,7 @@ public static void double4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -136,7 +136,7 @@ public static void double4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_not_equal_wide_wide() { double4 a0 = double4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048); @@ -160,7 +160,7 @@ public static void double4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_not_equal_wide_scalar() { double4 a0 = double4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137); @@ -184,7 +184,7 @@ public static void double4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -208,7 +208,7 @@ public static void double4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_less_wide_wide() { double4 a0 = double4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963); @@ -232,7 +232,7 @@ public static void double4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_less_wide_scalar() { double4 a0 = double4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561); @@ -256,7 +256,7 @@ public static void double4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -280,7 +280,7 @@ public static void double4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_greater_wide_wide() { double4 a0 = double4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671); @@ -304,7 +304,7 @@ public static void double4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_greater_wide_scalar() { double4 a0 = double4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157); @@ -328,7 +328,7 @@ public static void double4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -352,7 +352,7 @@ public static void double4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_less_equal_wide_wide() { double4 a0 = double4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857); @@ -376,7 +376,7 @@ public static void double4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_less_equal_wide_scalar() { double4 a0 = double4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292); @@ -400,7 +400,7 @@ public static void double4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -424,7 +424,7 @@ public static void double4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_greater_equal_wide_wide() { double4 a0 = double4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784); @@ -448,7 +448,7 @@ public static void double4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_greater_equal_wide_scalar() { double4 a0 = double4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356); @@ -472,7 +472,7 @@ public static void double4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -496,7 +496,7 @@ public static void double4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_add_wide_wide() { double4 a0 = double4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274); @@ -520,7 +520,7 @@ public static void double4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_add_wide_scalar() { double4 a0 = double4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752); @@ -544,7 +544,7 @@ public static void double4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -568,7 +568,7 @@ public static void double4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_sub_wide_wide() { double4 a0 = double4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311); @@ -592,7 +592,7 @@ public static void double4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_sub_wide_scalar() { double4 a0 = double4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506); @@ -616,7 +616,7 @@ public static void double4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -640,7 +640,7 @@ public static void double4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_mul_wide_wide() { double4 a0 = double4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182); @@ -664,7 +664,7 @@ public static void double4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_mul_wide_scalar() { double4 a0 = double4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409); @@ -688,7 +688,7 @@ public static void double4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -712,7 +712,7 @@ public static void double4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_div_wide_wide() { double4 a0 = double4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176); @@ -736,7 +736,7 @@ public static void double4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_div_wide_scalar() { double4 a0 = double4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078); @@ -760,7 +760,7 @@ public static void double4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -784,7 +784,7 @@ public static void double4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_mod_wide_wide() { double4 a0 = double4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813); @@ -808,7 +808,7 @@ public static void double4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_mod_wide_scalar() { double4 a0 = double4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672); @@ -832,7 +832,7 @@ public static void double4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -856,7 +856,7 @@ public static void double4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_plus() { double4 a0 = double4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421); @@ -876,7 +876,7 @@ public static void double4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_neg() { double4 a0 = double4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463); @@ -896,7 +896,7 @@ public static void double4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_prefix_inc() { double4 a0 = double4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962); @@ -916,7 +916,7 @@ public static void double4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_postfix_inc() { double4 a0 = double4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153); @@ -936,7 +936,7 @@ public static void double4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_prefix_dec() { double4 a0 = double4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563); @@ -956,7 +956,7 @@ public static void double4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_operator_postfix_dec() { double4 a0 = double4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962); @@ -976,7 +976,7 @@ public static void double4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_shuffle_result_1() { double4 a = double4(0, 1, 2, 3); @@ -992,7 +992,7 @@ public static void double4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_shuffle_result_2() { double4 a = double4(0, 1, 2, 3); @@ -1016,7 +1016,7 @@ public static void double4_shuffle_result_2() TestUtils.AreEqual(double2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_shuffle_result_3() { double4 a = double4(0, 1, 2, 3); @@ -1040,7 +1040,7 @@ public static void double4_shuffle_result_3() TestUtils.AreEqual(double3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_shuffle_result_4() { double4 a = double4(0, 1, 2, 3); @@ -1064,7 +1064,7 @@ public static void double4_shuffle_result_4() TestUtils.AreEqual(double4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void double4_EqualsObjectOverride() { TestUtils.IsFalse(new double4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs index 0e02dc29..112a10df 100644 --- a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_zero() { TestUtils.AreEqual(0.0, double4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void double4x2_zero() TestUtils.AreEqual(0.0, double4x2.zero.c1.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_equal_wide_wide() { double4x2 a0 = double4x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889); @@ -52,7 +52,7 @@ public static void double4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_equal_wide_scalar() { double4x2 a0 = double4x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405); @@ -76,7 +76,7 @@ public static void double4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -100,7 +100,7 @@ public static void double4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_not_equal_wide_wide() { double4x2 a0 = double4x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895); @@ -124,7 +124,7 @@ public static void double4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_not_equal_wide_scalar() { double4x2 a0 = double4x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842); @@ -148,7 +148,7 @@ public static void double4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -172,7 +172,7 @@ public static void double4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_less_wide_wide() { double4x2 a0 = double4x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259); @@ -196,7 +196,7 @@ public static void double4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_less_wide_scalar() { double4x2 a0 = double4x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061); @@ -220,7 +220,7 @@ public static void double4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -244,7 +244,7 @@ public static void double4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_greater_wide_wide() { double4x2 a0 = double4x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484); @@ -268,7 +268,7 @@ public static void double4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_greater_wide_scalar() { double4x2 a0 = double4x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972); @@ -292,7 +292,7 @@ public static void double4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -316,7 +316,7 @@ public static void double4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_less_equal_wide_wide() { double4x2 a0 = double4x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232); @@ -340,7 +340,7 @@ public static void double4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_less_equal_wide_scalar() { double4x2 a0 = double4x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582); @@ -364,7 +364,7 @@ public static void double4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -388,7 +388,7 @@ public static void double4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_greater_equal_wide_wide() { double4x2 a0 = double4x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265); @@ -412,7 +412,7 @@ public static void double4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_greater_equal_wide_scalar() { double4x2 a0 = double4x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838); @@ -436,7 +436,7 @@ public static void double4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -460,7 +460,7 @@ public static void double4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_add_wide_wide() { double4x2 a0 = double4x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656); @@ -484,7 +484,7 @@ public static void double4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_add_wide_scalar() { double4x2 a0 = double4x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454); @@ -508,7 +508,7 @@ public static void double4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -532,7 +532,7 @@ public static void double4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_sub_wide_wide() { double4x2 a0 = double4x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537); @@ -556,7 +556,7 @@ public static void double4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_sub_wide_scalar() { double4x2 a0 = double4x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965); @@ -580,7 +580,7 @@ public static void double4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -604,7 +604,7 @@ public static void double4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_mul_wide_wide() { double4x2 a0 = double4x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149); @@ -628,7 +628,7 @@ public static void double4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_mul_wide_scalar() { double4x2 a0 = double4x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334); @@ -652,7 +652,7 @@ public static void double4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -676,7 +676,7 @@ public static void double4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_div_wide_wide() { double4x2 a0 = double4x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537); @@ -700,7 +700,7 @@ public static void double4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_div_wide_scalar() { double4x2 a0 = double4x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539); @@ -724,7 +724,7 @@ public static void double4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -748,7 +748,7 @@ public static void double4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_mod_wide_wide() { double4x2 a0 = double4x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664); @@ -772,7 +772,7 @@ public static void double4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_mod_wide_scalar() { double4x2 a0 = double4x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243); @@ -796,7 +796,7 @@ public static void double4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -820,7 +820,7 @@ public static void double4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_plus() { double4x2 a0 = double4x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488); @@ -840,7 +840,7 @@ public static void double4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_neg() { double4x2 a0 = double4x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581); @@ -860,7 +860,7 @@ public static void double4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_prefix_inc() { double4x2 a0 = double4x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267); @@ -880,7 +880,7 @@ public static void double4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_postfix_inc() { double4x2 a0 = double4x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271); @@ -900,7 +900,7 @@ public static void double4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_prefix_dec() { double4x2 a0 = double4x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558); @@ -920,7 +920,7 @@ public static void double4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x2_operator_postfix_dec() { double4x2 a0 = double4x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568); @@ -940,7 +940,7 @@ public static void double4x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double4x2_EqualsObjectOverride() { TestUtils.IsFalse(new double4x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs index 66d6e952..90982950 100644 --- a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_zero() { TestUtils.AreEqual(0.0, double4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void double4x3_zero() TestUtils.AreEqual(0.0, double4x3.zero.c2.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_equal_wide_wide() { double4x3 a0 = double4x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078); @@ -56,7 +56,7 @@ public static void double4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_equal_wide_scalar() { double4x3 a0 = double4x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978); @@ -80,7 +80,7 @@ public static void double4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -104,7 +104,7 @@ public static void double4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_not_equal_wide_wide() { double4x3 a0 = double4x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394); @@ -128,7 +128,7 @@ public static void double4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_not_equal_wide_scalar() { double4x3 a0 = double4x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992); @@ -152,7 +152,7 @@ public static void double4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -176,7 +176,7 @@ public static void double4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_less_wide_wide() { double4x3 a0 = double4x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725); @@ -200,7 +200,7 @@ public static void double4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_less_wide_scalar() { double4x3 a0 = double4x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562); @@ -224,7 +224,7 @@ public static void double4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -248,7 +248,7 @@ public static void double4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_greater_wide_wide() { double4x3 a0 = double4x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906); @@ -272,7 +272,7 @@ public static void double4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_greater_wide_scalar() { double4x3 a0 = double4x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745); @@ -296,7 +296,7 @@ public static void double4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -320,7 +320,7 @@ public static void double4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_less_equal_wide_wide() { double4x3 a0 = double4x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363); @@ -344,7 +344,7 @@ public static void double4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_less_equal_wide_scalar() { double4x3 a0 = double4x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836); @@ -368,7 +368,7 @@ public static void double4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -392,7 +392,7 @@ public static void double4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_greater_equal_wide_wide() { double4x3 a0 = double4x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473); @@ -416,7 +416,7 @@ public static void double4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_greater_equal_wide_scalar() { double4x3 a0 = double4x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435); @@ -440,7 +440,7 @@ public static void double4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -464,7 +464,7 @@ public static void double4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_add_wide_wide() { double4x3 a0 = double4x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627); @@ -488,7 +488,7 @@ public static void double4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_add_wide_scalar() { double4x3 a0 = double4x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649); @@ -512,7 +512,7 @@ public static void double4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -536,7 +536,7 @@ public static void double4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_sub_wide_wide() { double4x3 a0 = double4x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149); @@ -560,7 +560,7 @@ public static void double4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_sub_wide_scalar() { double4x3 a0 = double4x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335); @@ -584,7 +584,7 @@ public static void double4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -608,7 +608,7 @@ public static void double4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_mul_wide_wide() { double4x3 a0 = double4x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408); @@ -632,7 +632,7 @@ public static void double4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_mul_wide_scalar() { double4x3 a0 = double4x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186); @@ -656,7 +656,7 @@ public static void double4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -680,7 +680,7 @@ public static void double4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_div_wide_wide() { double4x3 a0 = double4x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039); @@ -704,7 +704,7 @@ public static void double4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_div_wide_scalar() { double4x3 a0 = double4x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787); @@ -728,7 +728,7 @@ public static void double4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -752,7 +752,7 @@ public static void double4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_mod_wide_wide() { double4x3 a0 = double4x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538); @@ -776,7 +776,7 @@ public static void double4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_mod_wide_scalar() { double4x3 a0 = double4x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423); @@ -800,7 +800,7 @@ public static void double4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -824,7 +824,7 @@ public static void double4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_plus() { double4x3 a0 = double4x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724); @@ -844,7 +844,7 @@ public static void double4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_neg() { double4x3 a0 = double4x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852); @@ -864,7 +864,7 @@ public static void double4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_prefix_inc() { double4x3 a0 = double4x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212); @@ -884,7 +884,7 @@ public static void double4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_postfix_inc() { double4x3 a0 = double4x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185); @@ -904,7 +904,7 @@ public static void double4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_prefix_dec() { double4x3 a0 = double4x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956); @@ -924,7 +924,7 @@ public static void double4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x3_operator_postfix_dec() { double4x3 a0 = double4x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677); @@ -944,7 +944,7 @@ public static void double4x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double4x3_EqualsObjectOverride() { TestUtils.IsFalse(new double4x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs index bd638617..8c982bb3 100644 --- a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_zero() { TestUtils.AreEqual(0.0, double4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void double4x4_zero() TestUtils.AreEqual(0.0, double4x4.zero.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_identity() { TestUtils.AreEqual(1.0, double4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void double4x4_identity() TestUtils.AreEqual(1.0, double4x4.identity.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_equal_wide_wide() { double4x4 a0 = double4x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078, 109.63436918595539, 462.69031283943468, -335.38147727371262, 357.23446934168896); @@ -81,7 +81,7 @@ public static void double4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_equal_wide_scalar() { double4x4 a0 = double4x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978, -172.03530629539642, 455.40001198993991, -11.338988547836891, 363.93823044557973); @@ -105,7 +105,7 @@ public static void double4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -129,7 +129,7 @@ public static void double4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_not_equal_wide_wide() { double4x4 a0 = double4x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394, 65.662074358045174, 102.78780250567377, 172.93008120960098, 26.621009123800832); @@ -153,7 +153,7 @@ public static void double4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_not_equal_wide_scalar() { double4x4 a0 = double4x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992, -269.80570877241234, 299.65422763473089, -71.750904831919286, -432.75573917513515); @@ -177,7 +177,7 @@ public static void double4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -201,7 +201,7 @@ public static void double4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_less_wide_wide() { double4x4 a0 = double4x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725, -111.12994127680076, 70.005523475820951, 448.19828173527412, -419.98711200244122); @@ -225,7 +225,7 @@ public static void double4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_less_wide_scalar() { double4x4 a0 = double4x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562, 373.54965584983563, 398.52368301829495, 105.0301654827922, -58.010895994496934); @@ -249,7 +249,7 @@ public static void double4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -273,7 +273,7 @@ public static void double4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_greater_wide_wide() { double4x4 a0 = double4x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906, 455.85146662958505, 144.70691139283917, 63.931990891663304, -285.68304099034663); @@ -297,7 +297,7 @@ public static void double4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_greater_wide_scalar() { double4x4 a0 = double4x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745, 370.27919524269146, -413.70138116073861, -356.5923551789449, -353.03129522550444); @@ -321,7 +321,7 @@ public static void double4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -345,7 +345,7 @@ public static void double4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_less_equal_wide_wide() { double4x4 a0 = double4x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363, 149.736484835733, -418.8866781754823, -197.50252899783783, -88.2055118494693); @@ -369,7 +369,7 @@ public static void double4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_less_equal_wide_scalar() { double4x4 a0 = double4x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836, -264.93778264938749, 82.258299150624453, 11.246050124636895, 424.7040156911612); @@ -393,7 +393,7 @@ public static void double4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -417,7 +417,7 @@ public static void double4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_greater_equal_wide_wide() { double4x4 a0 = double4x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473, -309.57021608463032, -136.02249127999994, 280.73629082401112, -96.9958942388165); @@ -441,7 +441,7 @@ public static void double4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_greater_equal_wide_scalar() { double4x4 a0 = double4x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435, -36.994287269652943, 494.82028865014217, -164.97393830352183, -466.12009046325466); @@ -465,7 +465,7 @@ public static void double4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -489,7 +489,7 @@ public static void double4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_add_wide_wide() { double4x4 a0 = double4x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627, 69.195687564646732, -177.95734485329939, 299.60415544156183, 340.7048587001417); @@ -513,7 +513,7 @@ public static void double4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_add_wide_scalar() { double4x4 a0 = double4x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649, -188.26501068298938, -213.52673087526426, -267.78430688929944, 189.25996669999324); @@ -537,7 +537,7 @@ public static void double4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -561,7 +561,7 @@ public static void double4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_sub_wide_wide() { double4x4 a0 = double4x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149, 24.875419389864192, 366.61447136784648, -107.3741567634857, -219.0081404275299); @@ -585,7 +585,7 @@ public static void double4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_sub_wide_scalar() { double4x4 a0 = double4x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335, 349.39776460705218, 439.07729336203886, 490.2222661870635, 195.02405104181923); @@ -609,7 +609,7 @@ public static void double4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -633,7 +633,7 @@ public static void double4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_mul_wide_wide() { double4x4 a0 = double4x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408, -262.68257415605831, -379.26274674910246, -374.09058182970182, 481.44738720424812); @@ -657,7 +657,7 @@ public static void double4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_mul_wide_scalar() { double4x4 a0 = double4x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186, -207.35010275959507, -383.93960946795517, -31.425238862366086, 42.676120539510634); @@ -681,7 +681,7 @@ public static void double4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -705,7 +705,7 @@ public static void double4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_div_wide_wide() { double4x4 a0 = double4x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039, -416.22613234828509, -450.01919362042992, -273.49744594911925, -286.90817011841955); @@ -729,7 +729,7 @@ public static void double4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_div_wide_scalar() { double4x4 a0 = double4x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787, -205.03382143985192, 481.73814247629514, 464.47907159499778, -293.46349753693841); @@ -753,7 +753,7 @@ public static void double4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -777,7 +777,7 @@ public static void double4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_mod_wide_wide() { double4x4 a0 = double4x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538, -124.03371745163281, 259.27395761165485, -274.35845030208975, -140.03080398404541); @@ -801,7 +801,7 @@ public static void double4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_mod_wide_scalar() { double4x4 a0 = double4x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423, -355.84685985923136, 259.37800061860025, -330.87193957477433, -284.34358109363518); @@ -825,7 +825,7 @@ public static void double4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -849,7 +849,7 @@ public static void double4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_plus() { double4x4 a0 = double4x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724, -170.74650843941907, 439.55937572920664, -478.74939916969714, 116.40075665172219); @@ -869,7 +869,7 @@ public static void double4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_neg() { double4x4 a0 = double4x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852, 466.44152829909763, 171.90249474900895, -280.55831564616335, -78.85761622286293); @@ -889,7 +889,7 @@ public static void double4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_prefix_inc() { double4x4 a0 = double4x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212, 243.54693114177644, 46.19202735190845, -41.497298975241051, 299.18547000511808); @@ -909,7 +909,7 @@ public static void double4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_postfix_inc() { double4x4 a0 = double4x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185, 128.5304239394751, 73.155582223625629, -60.132380275117384, -446.22976490772783); @@ -929,7 +929,7 @@ public static void double4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_prefix_dec() { double4x4 a0 = double4x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956, -363.07547991493504, -22.028951416736902, 248.79012667797042, 168.0950144120003); @@ -949,7 +949,7 @@ public static void double4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4x4_operator_postfix_dec() { double4x4 a0 = double4x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677, -200.30429491787419, -445.0269393609031, 407.42034907239508, 327.67032519340069); @@ -969,7 +969,7 @@ public static void double4x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void double4x4_EqualsObjectOverride() { TestUtils.IsFalse(new double4x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat2.gen.cs b/src/Tests/Tests/Shared/TestFloat2.gen.cs index b14288cc..acacdb83 100644 --- a/src/Tests/Tests/Shared/TestFloat2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_zero() { TestUtils.AreEqual(0.0f, float2.zero.x); TestUtils.AreEqual(0.0f, float2.zero.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_constructor() { float2 a = new float2(1, 2); @@ -30,7 +30,7 @@ public static void float2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_scalar_constructor() { float2 a = new float2(17.0f); @@ -38,7 +38,7 @@ public static void float2_scalar_constructor() TestUtils.AreEqual(17.0f, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_static_constructor() { float2 a = float2(1, 2); @@ -46,7 +46,7 @@ public static void float2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_static_scalar_constructor() { float2 a = float2(17.0f); @@ -54,7 +54,7 @@ public static void float2_static_scalar_constructor() TestUtils.AreEqual(17.0f, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_equal_wide_wide() { float2 a0 = float2(492.1576f, -495.206329f); @@ -78,7 +78,7 @@ public static void float2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_equal_wide_scalar() { float2 a0 = float2(-303.230072f, 451.5263f); @@ -102,7 +102,7 @@ public static void float2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -126,7 +126,7 @@ public static void float2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_not_equal_wide_wide() { float2 a0 = float2(430.842529f, 104.69f); @@ -150,7 +150,7 @@ public static void float2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_not_equal_wide_scalar() { float2 a0 = float2(-16.9145813f, 168.8341f); @@ -174,7 +174,7 @@ public static void float2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -198,7 +198,7 @@ public static void float2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_less_wide_wide() { float2 a0 = float2(196.84259f, 336.4098f); @@ -222,7 +222,7 @@ public static void float2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_less_wide_scalar() { float2 a0 = float2(-132.057312f, -192.465f); @@ -246,7 +246,7 @@ public static void float2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -270,7 +270,7 @@ public static void float2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_greater_wide_wide() { float2 a0 = float2(483.5014f, 310.8156f); @@ -294,7 +294,7 @@ public static void float2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_greater_wide_scalar() { float2 a0 = float2(64.31793f, -397.703461f); @@ -318,7 +318,7 @@ public static void float2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -342,7 +342,7 @@ public static void float2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_less_equal_wide_wide() { float2 a0 = float2(-438.523132f, 210.489441f); @@ -366,7 +366,7 @@ public static void float2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_less_equal_wide_scalar() { float2 a0 = float2(193.49585f, 168.915527f); @@ -390,7 +390,7 @@ public static void float2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -414,7 +414,7 @@ public static void float2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_greater_equal_wide_wide() { float2 a0 = float2(-507.9286f, 504.4975f); @@ -438,7 +438,7 @@ public static void float2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_greater_equal_wide_scalar() { float2 a0 = float2(465.152161f, -424.886078f); @@ -462,7 +462,7 @@ public static void float2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -486,7 +486,7 @@ public static void float2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_add_wide_wide() { float2 a0 = float2(506.129028f, -501.779816f); @@ -510,7 +510,7 @@ public static void float2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_add_wide_scalar() { float2 a0 = float2(-194.514191f, 338.5484f); @@ -534,7 +534,7 @@ public static void float2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -558,7 +558,7 @@ public static void float2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_sub_wide_wide() { float2 a0 = float2(160.492249f, 11.223938f); @@ -582,7 +582,7 @@ public static void float2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_sub_wide_scalar() { float2 a0 = float2(207.389587f, 248.457764f); @@ -606,7 +606,7 @@ public static void float2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -630,7 +630,7 @@ public static void float2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_mul_wide_wide() { float2 a0 = float2(-482.7138f, -407.2935f); @@ -654,7 +654,7 @@ public static void float2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_mul_wide_scalar() { float2 a0 = float2(-96.31882f, -277.142273f); @@ -678,7 +678,7 @@ public static void float2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -702,7 +702,7 @@ public static void float2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_div_wide_wide() { float2 a0 = float2(-353.131439f, -102.799866f); @@ -726,7 +726,7 @@ public static void float2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_div_wide_scalar() { float2 a0 = float2(171.3424f, 0.103393555f); @@ -750,7 +750,7 @@ public static void float2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -774,7 +774,7 @@ public static void float2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_mod_wide_wide() { float2 a0 = float2(-388.8125f, 181.681213f); @@ -798,7 +798,7 @@ public static void float2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_mod_wide_scalar() { float2 a0 = float2(-244.499634f, -211.8193f); @@ -822,7 +822,7 @@ public static void float2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -846,7 +846,7 @@ public static void float2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_plus() { float2 a0 = float2(-418.829559f, -405.79895f); @@ -866,7 +866,7 @@ public static void float2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_neg() { float2 a0 = float2(148.461731f, -467.122681f); @@ -886,7 +886,7 @@ public static void float2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_prefix_inc() { float2 a0 = float2(-139.842072f, -56.7436523f); @@ -906,7 +906,7 @@ public static void float2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_postfix_inc() { float2 a0 = float2(-396.669739f, 511.20752f); @@ -926,7 +926,7 @@ public static void float2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_prefix_dec() { float2 a0 = float2(123.128723f, 256.84375f); @@ -946,7 +946,7 @@ public static void float2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_operator_postfix_dec() { float2 a0 = float2(379.6883f, 302.692871f); @@ -966,7 +966,7 @@ public static void float2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_shuffle_result_1() { float2 a = float2(0, 1); @@ -978,7 +978,7 @@ public static void float2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_shuffle_result_2() { float2 a = float2(0, 1); @@ -1002,7 +1002,7 @@ public static void float2_shuffle_result_2() TestUtils.AreEqual(float2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_shuffle_result_3() { float2 a = float2(0, 1); @@ -1026,7 +1026,7 @@ public static void float2_shuffle_result_3() TestUtils.AreEqual(float3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_shuffle_result_4() { float2 a = float2(0, 1); @@ -1050,7 +1050,7 @@ public static void float2_shuffle_result_4() TestUtils.AreEqual(float4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX)); } - [TestCase] + [TestCase /* For player builds */] public static void float2_EqualsObjectOverride() { TestUtils.IsFalse(new float2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs index 5b818da7..c5594164 100644 --- a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_zero() { TestUtils.AreEqual(0.0f, float2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void float2x2_zero() TestUtils.AreEqual(0.0f, float2x2.zero.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_identity() { TestUtils.AreEqual(1.0f, float2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void float2x2_identity() TestUtils.AreEqual(1.0f, float2x2.identity.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_equal_wide_wide() { float2x2 a0 = float2x2(492.1576f, -495.206329f, 227.457642f, -147.374054f); @@ -57,7 +57,7 @@ public static void float2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_equal_wide_scalar() { float2x2 a0 = float2x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f); @@ -81,7 +81,7 @@ public static void float2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -105,7 +105,7 @@ public static void float2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_not_equal_wide_wide() { float2x2 a0 = float2x2(430.842529f, 104.69f, 225.802429f, -310.5702f); @@ -129,7 +129,7 @@ public static void float2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_not_equal_wide_scalar() { float2x2 a0 = float2x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f); @@ -153,7 +153,7 @@ public static void float2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -177,7 +177,7 @@ public static void float2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_less_wide_wide() { float2x2 a0 = float2x2(196.84259f, 336.4098f, 251.963745f, 257.655945f); @@ -201,7 +201,7 @@ public static void float2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_less_wide_scalar() { float2x2 a0 = float2x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f); @@ -225,7 +225,7 @@ public static void float2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -249,7 +249,7 @@ public static void float2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_greater_wide_wide() { float2x2 a0 = float2x2(483.5014f, 310.8156f, 106.966187f, 295.7353f); @@ -273,7 +273,7 @@ public static void float2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_greater_wide_scalar() { float2x2 a0 = float2x2(64.31793f, -397.703461f, 431.8769f, 85.703f); @@ -297,7 +297,7 @@ public static void float2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -321,7 +321,7 @@ public static void float2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_less_equal_wide_wide() { float2x2 a0 = float2x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f); @@ -345,7 +345,7 @@ public static void float2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_less_equal_wide_scalar() { float2x2 a0 = float2x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f); @@ -369,7 +369,7 @@ public static void float2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -393,7 +393,7 @@ public static void float2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_greater_equal_wide_wide() { float2x2 a0 = float2x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f); @@ -417,7 +417,7 @@ public static void float2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_greater_equal_wide_scalar() { float2x2 a0 = float2x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f); @@ -441,7 +441,7 @@ public static void float2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -465,7 +465,7 @@ public static void float2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_add_wide_wide() { float2x2 a0 = float2x2(506.129028f, -501.779816f, 420.084778f, -186.032074f); @@ -489,7 +489,7 @@ public static void float2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_add_wide_scalar() { float2x2 a0 = float2x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f); @@ -513,7 +513,7 @@ public static void float2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -537,7 +537,7 @@ public static void float2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_sub_wide_wide() { float2x2 a0 = float2x2(160.492249f, 11.223938f, 359.200134f, -498.2283f); @@ -561,7 +561,7 @@ public static void float2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_sub_wide_scalar() { float2x2 a0 = float2x2(207.389587f, 248.457764f, -384.8239f, -205.344757f); @@ -585,7 +585,7 @@ public static void float2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -609,7 +609,7 @@ public static void float2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_mul_wide_wide() { float2x2 a0 = float2x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f); @@ -633,7 +633,7 @@ public static void float2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_mul_wide_scalar() { float2x2 a0 = float2x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f); @@ -657,7 +657,7 @@ public static void float2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -681,7 +681,7 @@ public static void float2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_div_wide_wide() { float2x2 a0 = float2x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f); @@ -705,7 +705,7 @@ public static void float2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_div_wide_scalar() { float2x2 a0 = float2x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f); @@ -729,7 +729,7 @@ public static void float2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -753,7 +753,7 @@ public static void float2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_mod_wide_wide() { float2x2 a0 = float2x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f); @@ -777,7 +777,7 @@ public static void float2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_mod_wide_scalar() { float2x2 a0 = float2x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f); @@ -801,7 +801,7 @@ public static void float2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -825,7 +825,7 @@ public static void float2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_plus() { float2x2 a0 = float2x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f); @@ -845,7 +845,7 @@ public static void float2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_neg() { float2x2 a0 = float2x2(148.461731f, -467.122681f, 132.04718f, 183.522644f); @@ -865,7 +865,7 @@ public static void float2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_prefix_inc() { float2x2 a0 = float2x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f); @@ -885,7 +885,7 @@ public static void float2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_postfix_inc() { float2x2 a0 = float2x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f); @@ -905,7 +905,7 @@ public static void float2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_prefix_dec() { float2x2 a0 = float2x2(123.128723f, 256.84375f, 156.330811f, 461.737427f); @@ -925,7 +925,7 @@ public static void float2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_operator_postfix_dec() { float2x2 a0 = float2x2(379.6883f, 302.692871f, -176.07135f, -291.2527f); @@ -945,7 +945,7 @@ public static void float2x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float2x2_EqualsObjectOverride() { TestUtils.IsFalse(new float2x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs index 8a93998c..e619dc0d 100644 --- a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_zero() { TestUtils.AreEqual(0.0f, float2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void float2x3_zero() TestUtils.AreEqual(0.0f, float2x3.zero.c2.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_equal_wide_wide() { float2x3 a0 = float2x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f); @@ -50,7 +50,7 @@ public static void float2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_equal_wide_scalar() { float2x3 a0 = float2x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f); @@ -74,7 +74,7 @@ public static void float2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -98,7 +98,7 @@ public static void float2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_not_equal_wide_wide() { float2x3 a0 = float2x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f); @@ -122,7 +122,7 @@ public static void float2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_not_equal_wide_scalar() { float2x3 a0 = float2x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f); @@ -146,7 +146,7 @@ public static void float2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -170,7 +170,7 @@ public static void float2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_less_wide_wide() { float2x3 a0 = float2x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f); @@ -194,7 +194,7 @@ public static void float2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_less_wide_scalar() { float2x3 a0 = float2x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f); @@ -218,7 +218,7 @@ public static void float2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -242,7 +242,7 @@ public static void float2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_greater_wide_wide() { float2x3 a0 = float2x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f); @@ -266,7 +266,7 @@ public static void float2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_greater_wide_scalar() { float2x3 a0 = float2x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f); @@ -290,7 +290,7 @@ public static void float2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -314,7 +314,7 @@ public static void float2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_less_equal_wide_wide() { float2x3 a0 = float2x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f); @@ -338,7 +338,7 @@ public static void float2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_less_equal_wide_scalar() { float2x3 a0 = float2x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f); @@ -362,7 +362,7 @@ public static void float2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -386,7 +386,7 @@ public static void float2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_greater_equal_wide_wide() { float2x3 a0 = float2x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f); @@ -410,7 +410,7 @@ public static void float2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_greater_equal_wide_scalar() { float2x3 a0 = float2x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f); @@ -434,7 +434,7 @@ public static void float2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -458,7 +458,7 @@ public static void float2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_add_wide_wide() { float2x3 a0 = float2x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f); @@ -482,7 +482,7 @@ public static void float2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_add_wide_scalar() { float2x3 a0 = float2x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f); @@ -506,7 +506,7 @@ public static void float2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -530,7 +530,7 @@ public static void float2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_sub_wide_wide() { float2x3 a0 = float2x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f); @@ -554,7 +554,7 @@ public static void float2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_sub_wide_scalar() { float2x3 a0 = float2x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f); @@ -578,7 +578,7 @@ public static void float2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -602,7 +602,7 @@ public static void float2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_mul_wide_wide() { float2x3 a0 = float2x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f); @@ -626,7 +626,7 @@ public static void float2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_mul_wide_scalar() { float2x3 a0 = float2x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f); @@ -650,7 +650,7 @@ public static void float2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -674,7 +674,7 @@ public static void float2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_div_wide_wide() { float2x3 a0 = float2x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f); @@ -698,7 +698,7 @@ public static void float2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_div_wide_scalar() { float2x3 a0 = float2x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f); @@ -722,7 +722,7 @@ public static void float2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -746,7 +746,7 @@ public static void float2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_mod_wide_wide() { float2x3 a0 = float2x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f); @@ -770,7 +770,7 @@ public static void float2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_mod_wide_scalar() { float2x3 a0 = float2x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f); @@ -794,7 +794,7 @@ public static void float2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -818,7 +818,7 @@ public static void float2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_plus() { float2x3 a0 = float2x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f); @@ -838,7 +838,7 @@ public static void float2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_neg() { float2x3 a0 = float2x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f); @@ -858,7 +858,7 @@ public static void float2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_prefix_inc() { float2x3 a0 = float2x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f); @@ -878,7 +878,7 @@ public static void float2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_postfix_inc() { float2x3 a0 = float2x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f); @@ -898,7 +898,7 @@ public static void float2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_prefix_dec() { float2x3 a0 = float2x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f); @@ -918,7 +918,7 @@ public static void float2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x3_operator_postfix_dec() { float2x3 a0 = float2x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f); @@ -938,7 +938,7 @@ public static void float2x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float2x3_EqualsObjectOverride() { TestUtils.IsFalse(new float2x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs index d959a802..19447921 100644 --- a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_zero() { TestUtils.AreEqual(0.0f, float2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void float2x4_zero() TestUtils.AreEqual(0.0f, float2x4.zero.c3.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_equal_wide_wide() { float2x4 a0 = float2x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f); @@ -52,7 +52,7 @@ public static void float2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_equal_wide_scalar() { float2x4 a0 = float2x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f); @@ -76,7 +76,7 @@ public static void float2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -100,7 +100,7 @@ public static void float2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_not_equal_wide_wide() { float2x4 a0 = float2x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f); @@ -124,7 +124,7 @@ public static void float2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_not_equal_wide_scalar() { float2x4 a0 = float2x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f); @@ -148,7 +148,7 @@ public static void float2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -172,7 +172,7 @@ public static void float2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_less_wide_wide() { float2x4 a0 = float2x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f); @@ -196,7 +196,7 @@ public static void float2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_less_wide_scalar() { float2x4 a0 = float2x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f); @@ -220,7 +220,7 @@ public static void float2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -244,7 +244,7 @@ public static void float2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_greater_wide_wide() { float2x4 a0 = float2x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f); @@ -268,7 +268,7 @@ public static void float2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_greater_wide_scalar() { float2x4 a0 = float2x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f); @@ -292,7 +292,7 @@ public static void float2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -316,7 +316,7 @@ public static void float2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_less_equal_wide_wide() { float2x4 a0 = float2x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f); @@ -340,7 +340,7 @@ public static void float2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_less_equal_wide_scalar() { float2x4 a0 = float2x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f); @@ -364,7 +364,7 @@ public static void float2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -388,7 +388,7 @@ public static void float2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_greater_equal_wide_wide() { float2x4 a0 = float2x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f); @@ -412,7 +412,7 @@ public static void float2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_greater_equal_wide_scalar() { float2x4 a0 = float2x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f); @@ -436,7 +436,7 @@ public static void float2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -460,7 +460,7 @@ public static void float2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_add_wide_wide() { float2x4 a0 = float2x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f); @@ -484,7 +484,7 @@ public static void float2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_add_wide_scalar() { float2x4 a0 = float2x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f); @@ -508,7 +508,7 @@ public static void float2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -532,7 +532,7 @@ public static void float2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_sub_wide_wide() { float2x4 a0 = float2x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f); @@ -556,7 +556,7 @@ public static void float2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_sub_wide_scalar() { float2x4 a0 = float2x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f); @@ -580,7 +580,7 @@ public static void float2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -604,7 +604,7 @@ public static void float2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_mul_wide_wide() { float2x4 a0 = float2x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f); @@ -628,7 +628,7 @@ public static void float2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_mul_wide_scalar() { float2x4 a0 = float2x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f); @@ -652,7 +652,7 @@ public static void float2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -676,7 +676,7 @@ public static void float2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_div_wide_wide() { float2x4 a0 = float2x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f); @@ -700,7 +700,7 @@ public static void float2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_div_wide_scalar() { float2x4 a0 = float2x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f); @@ -724,7 +724,7 @@ public static void float2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -748,7 +748,7 @@ public static void float2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_mod_wide_wide() { float2x4 a0 = float2x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f); @@ -772,7 +772,7 @@ public static void float2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_mod_wide_scalar() { float2x4 a0 = float2x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f); @@ -796,7 +796,7 @@ public static void float2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -820,7 +820,7 @@ public static void float2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_plus() { float2x4 a0 = float2x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f); @@ -840,7 +840,7 @@ public static void float2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_neg() { float2x4 a0 = float2x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f); @@ -860,7 +860,7 @@ public static void float2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_prefix_inc() { float2x4 a0 = float2x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f); @@ -880,7 +880,7 @@ public static void float2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_postfix_inc() { float2x4 a0 = float2x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f); @@ -900,7 +900,7 @@ public static void float2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_prefix_dec() { float2x4 a0 = float2x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f); @@ -920,7 +920,7 @@ public static void float2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x4_operator_postfix_dec() { float2x4 a0 = float2x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f); @@ -940,7 +940,7 @@ public static void float2x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float2x4_EqualsObjectOverride() { TestUtils.IsFalse(new float2x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat3.gen.cs b/src/Tests/Tests/Shared/TestFloat3.gen.cs index 48c5b1a4..40a4db85 100644 --- a/src/Tests/Tests/Shared/TestFloat3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_zero() { TestUtils.AreEqual(0.0f, float3.zero.x); @@ -23,7 +23,7 @@ public static void float3_zero() TestUtils.AreEqual(0.0f, float3.zero.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_constructor() { float3 a = new float3(1, 2, 3); @@ -32,7 +32,7 @@ public static void float3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_scalar_constructor() { float3 a = new float3(17.0f); @@ -41,7 +41,7 @@ public static void float3_scalar_constructor() TestUtils.AreEqual(17.0f, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_static_constructor() { float3 a = float3(1, 2, 3); @@ -50,7 +50,7 @@ public static void float3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_static_scalar_constructor() { float3 a = float3(17.0f); @@ -59,7 +59,7 @@ public static void float3_static_scalar_constructor() TestUtils.AreEqual(17.0f, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_equal_wide_wide() { float3 a0 = float3(492.1576f, -495.206329f, 227.457642f); @@ -83,7 +83,7 @@ public static void float3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_equal_wide_scalar() { float3 a0 = float3(-303.230072f, 451.5263f, -253.655884f); @@ -107,7 +107,7 @@ public static void float3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -131,7 +131,7 @@ public static void float3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_not_equal_wide_wide() { float3 a0 = float3(430.842529f, 104.69f, 225.802429f); @@ -155,7 +155,7 @@ public static void float3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_not_equal_wide_scalar() { float3 a0 = float3(-16.9145813f, 168.8341f, -462.713531f); @@ -179,7 +179,7 @@ public static void float3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -203,7 +203,7 @@ public static void float3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_less_wide_wide() { float3 a0 = float3(196.84259f, 336.4098f, 251.963745f); @@ -227,7 +227,7 @@ public static void float3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_less_wide_scalar() { float3 a0 = float3(-132.057312f, -192.465f, -66.8345947f); @@ -251,7 +251,7 @@ public static void float3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -275,7 +275,7 @@ public static void float3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_greater_wide_wide() { float3 a0 = float3(483.5014f, 310.8156f, 106.966187f); @@ -299,7 +299,7 @@ public static void float3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_greater_wide_scalar() { float3 a0 = float3(64.31793f, -397.703461f, 431.8769f); @@ -323,7 +323,7 @@ public static void float3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -347,7 +347,7 @@ public static void float3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_less_equal_wide_wide() { float3 a0 = float3(-438.523132f, 210.489441f, 4.87731934f); @@ -371,7 +371,7 @@ public static void float3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_less_equal_wide_scalar() { float3 a0 = float3(193.49585f, 168.915527f, -313.993073f); @@ -395,7 +395,7 @@ public static void float3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -419,7 +419,7 @@ public static void float3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_greater_equal_wide_wide() { float3 a0 = float3(-507.9286f, 504.4975f, -385.4345f); @@ -443,7 +443,7 @@ public static void float3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_greater_equal_wide_scalar() { float3 a0 = float3(465.152161f, -424.886078f, -209.2211f); @@ -467,7 +467,7 @@ public static void float3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -491,7 +491,7 @@ public static void float3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_add_wide_wide() { float3 a0 = float3(506.129028f, -501.779816f, 420.084778f); @@ -515,7 +515,7 @@ public static void float3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_add_wide_scalar() { float3 a0 = float3(-194.514191f, 338.5484f, 246.971375f); @@ -539,7 +539,7 @@ public static void float3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -563,7 +563,7 @@ public static void float3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_sub_wide_wide() { float3 a0 = float3(160.492249f, 11.223938f, 359.200134f); @@ -587,7 +587,7 @@ public static void float3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_sub_wide_scalar() { float3 a0 = float3(207.389587f, 248.457764f, -384.8239f); @@ -611,7 +611,7 @@ public static void float3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -635,7 +635,7 @@ public static void float3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_mul_wide_wide() { float3 a0 = float3(-482.7138f, -407.2935f, 137.700562f); @@ -659,7 +659,7 @@ public static void float3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_mul_wide_scalar() { float3 a0 = float3(-96.31882f, -277.142273f, -239.93689f); @@ -683,7 +683,7 @@ public static void float3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -707,7 +707,7 @@ public static void float3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_div_wide_wide() { float3 a0 = float3(-353.131439f, -102.799866f, 51.3191528f); @@ -731,7 +731,7 @@ public static void float3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_div_wide_scalar() { float3 a0 = float3(171.3424f, 0.103393555f, 57.8882446f); @@ -755,7 +755,7 @@ public static void float3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -779,7 +779,7 @@ public static void float3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_mod_wide_wide() { float3 a0 = float3(-388.8125f, 181.681213f, -167.078735f); @@ -803,7 +803,7 @@ public static void float3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_mod_wide_scalar() { float3 a0 = float3(-244.499634f, -211.8193f, -145.926788f); @@ -827,7 +827,7 @@ public static void float3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -851,7 +851,7 @@ public static void float3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_plus() { float3 a0 = float3(-418.829559f, -405.79895f, -34.04178f); @@ -871,7 +871,7 @@ public static void float3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_neg() { float3 a0 = float3(148.461731f, -467.122681f, 132.04718f); @@ -891,7 +891,7 @@ public static void float3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_prefix_inc() { float3 a0 = float3(-139.842072f, -56.7436523f, -381.955322f); @@ -911,7 +911,7 @@ public static void float3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_postfix_inc() { float3 a0 = float3(-396.669739f, 511.20752f, 249.111267f); @@ -931,7 +931,7 @@ public static void float3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_prefix_dec() { float3 a0 = float3(123.128723f, 256.84375f, 156.330811f); @@ -951,7 +951,7 @@ public static void float3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_operator_postfix_dec() { float3 a0 = float3(379.6883f, 302.692871f, -176.07135f); @@ -971,7 +971,7 @@ public static void float3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_shuffle_result_1() { float3 a = float3(0, 1, 2); @@ -985,7 +985,7 @@ public static void float3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_shuffle_result_2() { float3 a = float3(0, 1, 2); @@ -1009,7 +1009,7 @@ public static void float3_shuffle_result_2() TestUtils.AreEqual(float2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_shuffle_result_3() { float3 a = float3(0, 1, 2); @@ -1033,7 +1033,7 @@ public static void float3_shuffle_result_3() TestUtils.AreEqual(float3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_shuffle_result_4() { float3 a = float3(0, 1, 2); @@ -1057,7 +1057,7 @@ public static void float3_shuffle_result_4() TestUtils.AreEqual(float4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void float3_EqualsObjectOverride() { TestUtils.IsFalse(new float3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs index a497e7be..dabe0e58 100644 --- a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_zero() { TestUtils.AreEqual(0.0f, float3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void float3x2_zero() TestUtils.AreEqual(0.0f, float3x2.zero.c1.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_equal_wide_wide() { float3x2 a0 = float3x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f); @@ -50,7 +50,7 @@ public static void float3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_equal_wide_scalar() { float3x2 a0 = float3x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f); @@ -74,7 +74,7 @@ public static void float3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -98,7 +98,7 @@ public static void float3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_not_equal_wide_wide() { float3x2 a0 = float3x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f); @@ -122,7 +122,7 @@ public static void float3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_not_equal_wide_scalar() { float3x2 a0 = float3x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f); @@ -146,7 +146,7 @@ public static void float3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -170,7 +170,7 @@ public static void float3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_less_wide_wide() { float3x2 a0 = float3x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f); @@ -194,7 +194,7 @@ public static void float3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_less_wide_scalar() { float3x2 a0 = float3x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f); @@ -218,7 +218,7 @@ public static void float3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -242,7 +242,7 @@ public static void float3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_greater_wide_wide() { float3x2 a0 = float3x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f); @@ -266,7 +266,7 @@ public static void float3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_greater_wide_scalar() { float3x2 a0 = float3x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f); @@ -290,7 +290,7 @@ public static void float3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -314,7 +314,7 @@ public static void float3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_less_equal_wide_wide() { float3x2 a0 = float3x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f); @@ -338,7 +338,7 @@ public static void float3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_less_equal_wide_scalar() { float3x2 a0 = float3x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f); @@ -362,7 +362,7 @@ public static void float3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -386,7 +386,7 @@ public static void float3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_greater_equal_wide_wide() { float3x2 a0 = float3x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f); @@ -410,7 +410,7 @@ public static void float3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_greater_equal_wide_scalar() { float3x2 a0 = float3x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f); @@ -434,7 +434,7 @@ public static void float3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -458,7 +458,7 @@ public static void float3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_add_wide_wide() { float3x2 a0 = float3x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f); @@ -482,7 +482,7 @@ public static void float3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_add_wide_scalar() { float3x2 a0 = float3x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f); @@ -506,7 +506,7 @@ public static void float3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -530,7 +530,7 @@ public static void float3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_sub_wide_wide() { float3x2 a0 = float3x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f); @@ -554,7 +554,7 @@ public static void float3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_sub_wide_scalar() { float3x2 a0 = float3x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f); @@ -578,7 +578,7 @@ public static void float3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -602,7 +602,7 @@ public static void float3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_mul_wide_wide() { float3x2 a0 = float3x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f); @@ -626,7 +626,7 @@ public static void float3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_mul_wide_scalar() { float3x2 a0 = float3x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f); @@ -650,7 +650,7 @@ public static void float3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -674,7 +674,7 @@ public static void float3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_div_wide_wide() { float3x2 a0 = float3x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f); @@ -698,7 +698,7 @@ public static void float3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_div_wide_scalar() { float3x2 a0 = float3x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f); @@ -722,7 +722,7 @@ public static void float3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -746,7 +746,7 @@ public static void float3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_mod_wide_wide() { float3x2 a0 = float3x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f); @@ -770,7 +770,7 @@ public static void float3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_mod_wide_scalar() { float3x2 a0 = float3x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f); @@ -794,7 +794,7 @@ public static void float3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -818,7 +818,7 @@ public static void float3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_plus() { float3x2 a0 = float3x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f); @@ -838,7 +838,7 @@ public static void float3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_neg() { float3x2 a0 = float3x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f); @@ -858,7 +858,7 @@ public static void float3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_prefix_inc() { float3x2 a0 = float3x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f); @@ -878,7 +878,7 @@ public static void float3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_postfix_inc() { float3x2 a0 = float3x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f); @@ -898,7 +898,7 @@ public static void float3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_prefix_dec() { float3x2 a0 = float3x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f); @@ -918,7 +918,7 @@ public static void float3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x2_operator_postfix_dec() { float3x2 a0 = float3x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f); @@ -938,7 +938,7 @@ public static void float3x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float3x2_EqualsObjectOverride() { TestUtils.IsFalse(new float3x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs index 37e72288..6326f34f 100644 --- a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_zero() { TestUtils.AreEqual(0.0f, float3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void float3x3_zero() TestUtils.AreEqual(0.0f, float3x3.zero.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_identity() { TestUtils.AreEqual(1.0f, float3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void float3x3_identity() TestUtils.AreEqual(1.0f, float3x3.identity.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_equal_wide_wide() { float3x3 a0 = float3x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f); @@ -67,7 +67,7 @@ public static void float3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_equal_wide_scalar() { float3x3 a0 = float3x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f); @@ -91,7 +91,7 @@ public static void float3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -115,7 +115,7 @@ public static void float3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_not_equal_wide_wide() { float3x3 a0 = float3x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f); @@ -139,7 +139,7 @@ public static void float3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_not_equal_wide_scalar() { float3x3 a0 = float3x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f); @@ -163,7 +163,7 @@ public static void float3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -187,7 +187,7 @@ public static void float3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_less_wide_wide() { float3x3 a0 = float3x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f); @@ -211,7 +211,7 @@ public static void float3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_less_wide_scalar() { float3x3 a0 = float3x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f); @@ -235,7 +235,7 @@ public static void float3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -259,7 +259,7 @@ public static void float3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_greater_wide_wide() { float3x3 a0 = float3x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f); @@ -283,7 +283,7 @@ public static void float3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_greater_wide_scalar() { float3x3 a0 = float3x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f); @@ -307,7 +307,7 @@ public static void float3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -331,7 +331,7 @@ public static void float3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_less_equal_wide_wide() { float3x3 a0 = float3x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f); @@ -355,7 +355,7 @@ public static void float3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_less_equal_wide_scalar() { float3x3 a0 = float3x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f); @@ -379,7 +379,7 @@ public static void float3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -403,7 +403,7 @@ public static void float3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_greater_equal_wide_wide() { float3x3 a0 = float3x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f); @@ -427,7 +427,7 @@ public static void float3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_greater_equal_wide_scalar() { float3x3 a0 = float3x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f); @@ -451,7 +451,7 @@ public static void float3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -475,7 +475,7 @@ public static void float3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_add_wide_wide() { float3x3 a0 = float3x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f); @@ -499,7 +499,7 @@ public static void float3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_add_wide_scalar() { float3x3 a0 = float3x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f); @@ -523,7 +523,7 @@ public static void float3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -547,7 +547,7 @@ public static void float3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_sub_wide_wide() { float3x3 a0 = float3x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f); @@ -571,7 +571,7 @@ public static void float3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_sub_wide_scalar() { float3x3 a0 = float3x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f); @@ -595,7 +595,7 @@ public static void float3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -619,7 +619,7 @@ public static void float3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_mul_wide_wide() { float3x3 a0 = float3x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f); @@ -643,7 +643,7 @@ public static void float3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_mul_wide_scalar() { float3x3 a0 = float3x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f); @@ -667,7 +667,7 @@ public static void float3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -691,7 +691,7 @@ public static void float3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_div_wide_wide() { float3x3 a0 = float3x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f); @@ -715,7 +715,7 @@ public static void float3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_div_wide_scalar() { float3x3 a0 = float3x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f); @@ -739,7 +739,7 @@ public static void float3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -763,7 +763,7 @@ public static void float3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_mod_wide_wide() { float3x3 a0 = float3x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f); @@ -787,7 +787,7 @@ public static void float3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_mod_wide_scalar() { float3x3 a0 = float3x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f); @@ -811,7 +811,7 @@ public static void float3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -835,7 +835,7 @@ public static void float3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_plus() { float3x3 a0 = float3x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f); @@ -855,7 +855,7 @@ public static void float3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_neg() { float3x3 a0 = float3x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f); @@ -875,7 +875,7 @@ public static void float3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_prefix_inc() { float3x3 a0 = float3x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f); @@ -895,7 +895,7 @@ public static void float3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_postfix_inc() { float3x3 a0 = float3x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f); @@ -915,7 +915,7 @@ public static void float3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_prefix_dec() { float3x3 a0 = float3x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f); @@ -935,7 +935,7 @@ public static void float3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_operator_postfix_dec() { float3x3 a0 = float3x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f); @@ -955,7 +955,7 @@ public static void float3x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float3x3_EqualsObjectOverride() { TestUtils.IsFalse(new float3x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs index 57e75392..78522532 100644 --- a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_zero() { TestUtils.AreEqual(0.0f, float3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void float3x4_zero() TestUtils.AreEqual(0.0f, float3x4.zero.c3.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_equal_wide_wide() { float3x4 a0 = float3x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f); @@ -56,7 +56,7 @@ public static void float3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_equal_wide_scalar() { float3x4 a0 = float3x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f); @@ -80,7 +80,7 @@ public static void float3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -104,7 +104,7 @@ public static void float3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_not_equal_wide_wide() { float3x4 a0 = float3x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f); @@ -128,7 +128,7 @@ public static void float3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_not_equal_wide_scalar() { float3x4 a0 = float3x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f); @@ -152,7 +152,7 @@ public static void float3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -176,7 +176,7 @@ public static void float3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_less_wide_wide() { float3x4 a0 = float3x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f); @@ -200,7 +200,7 @@ public static void float3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_less_wide_scalar() { float3x4 a0 = float3x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f); @@ -224,7 +224,7 @@ public static void float3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -248,7 +248,7 @@ public static void float3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_greater_wide_wide() { float3x4 a0 = float3x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f); @@ -272,7 +272,7 @@ public static void float3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_greater_wide_scalar() { float3x4 a0 = float3x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f); @@ -296,7 +296,7 @@ public static void float3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -320,7 +320,7 @@ public static void float3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_less_equal_wide_wide() { float3x4 a0 = float3x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f); @@ -344,7 +344,7 @@ public static void float3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_less_equal_wide_scalar() { float3x4 a0 = float3x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f); @@ -368,7 +368,7 @@ public static void float3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -392,7 +392,7 @@ public static void float3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_greater_equal_wide_wide() { float3x4 a0 = float3x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f); @@ -416,7 +416,7 @@ public static void float3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_greater_equal_wide_scalar() { float3x4 a0 = float3x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f); @@ -440,7 +440,7 @@ public static void float3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -464,7 +464,7 @@ public static void float3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_add_wide_wide() { float3x4 a0 = float3x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f); @@ -488,7 +488,7 @@ public static void float3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_add_wide_scalar() { float3x4 a0 = float3x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f); @@ -512,7 +512,7 @@ public static void float3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -536,7 +536,7 @@ public static void float3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_sub_wide_wide() { float3x4 a0 = float3x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f); @@ -560,7 +560,7 @@ public static void float3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_sub_wide_scalar() { float3x4 a0 = float3x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f); @@ -584,7 +584,7 @@ public static void float3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -608,7 +608,7 @@ public static void float3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_mul_wide_wide() { float3x4 a0 = float3x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f); @@ -632,7 +632,7 @@ public static void float3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_mul_wide_scalar() { float3x4 a0 = float3x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f); @@ -656,7 +656,7 @@ public static void float3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -680,7 +680,7 @@ public static void float3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_div_wide_wide() { float3x4 a0 = float3x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f); @@ -704,7 +704,7 @@ public static void float3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_div_wide_scalar() { float3x4 a0 = float3x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f); @@ -728,7 +728,7 @@ public static void float3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -752,7 +752,7 @@ public static void float3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_mod_wide_wide() { float3x4 a0 = float3x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f); @@ -776,7 +776,7 @@ public static void float3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_mod_wide_scalar() { float3x4 a0 = float3x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f); @@ -800,7 +800,7 @@ public static void float3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -824,7 +824,7 @@ public static void float3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_plus() { float3x4 a0 = float3x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f); @@ -844,7 +844,7 @@ public static void float3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_neg() { float3x4 a0 = float3x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f); @@ -864,7 +864,7 @@ public static void float3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_prefix_inc() { float3x4 a0 = float3x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f); @@ -884,7 +884,7 @@ public static void float3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_postfix_inc() { float3x4 a0 = float3x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f); @@ -904,7 +904,7 @@ public static void float3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_prefix_dec() { float3x4 a0 = float3x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f); @@ -924,7 +924,7 @@ public static void float3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_operator_postfix_dec() { float3x4 a0 = float3x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f); @@ -944,7 +944,7 @@ public static void float3x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float3x4_EqualsObjectOverride() { TestUtils.IsFalse(new float3x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat4.gen.cs b/src/Tests/Tests/Shared/TestFloat4.gen.cs index eec3bd88..9ac6757c 100644 --- a/src/Tests/Tests/Shared/TestFloat4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_zero() { TestUtils.AreEqual(0.0f, float4.zero.x); @@ -24,7 +24,7 @@ public static void float4_zero() TestUtils.AreEqual(0.0f, float4.zero.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_constructor() { float4 a = new float4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void float4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_scalar_constructor() { float4 a = new float4(17.0f); @@ -44,7 +44,7 @@ public static void float4_scalar_constructor() TestUtils.AreEqual(17.0f, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_static_constructor() { float4 a = float4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void float4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_static_scalar_constructor() { float4 a = float4(17.0f); @@ -64,7 +64,7 @@ public static void float4_static_scalar_constructor() TestUtils.AreEqual(17.0f, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_equal_wide_wide() { float4 a0 = float4(492.1576f, -495.206329f, 227.457642f, -147.374054f); @@ -88,7 +88,7 @@ public static void float4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_equal_wide_scalar() { float4 a0 = float4(-303.230072f, 451.5263f, -253.655884f, -105.203644f); @@ -112,7 +112,7 @@ public static void float4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -136,7 +136,7 @@ public static void float4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_not_equal_wide_wide() { float4 a0 = float4(430.842529f, 104.69f, 225.802429f, -310.5702f); @@ -160,7 +160,7 @@ public static void float4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_not_equal_wide_scalar() { float4 a0 = float4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f); @@ -184,7 +184,7 @@ public static void float4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -208,7 +208,7 @@ public static void float4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_less_wide_wide() { float4 a0 = float4(196.84259f, 336.4098f, 251.963745f, 257.655945f); @@ -232,7 +232,7 @@ public static void float4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_less_wide_scalar() { float4 a0 = float4(-132.057312f, -192.465f, -66.8345947f, -379.017517f); @@ -256,7 +256,7 @@ public static void float4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -280,7 +280,7 @@ public static void float4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_greater_wide_wide() { float4 a0 = float4(483.5014f, 310.8156f, 106.966187f, 295.7353f); @@ -304,7 +304,7 @@ public static void float4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_greater_wide_scalar() { float4 a0 = float4(64.31793f, -397.703461f, 431.8769f, 85.703f); @@ -328,7 +328,7 @@ public static void float4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -352,7 +352,7 @@ public static void float4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_less_equal_wide_wide() { float4 a0 = float4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f); @@ -376,7 +376,7 @@ public static void float4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_less_equal_wide_scalar() { float4 a0 = float4(193.49585f, 168.915527f, -313.993073f, 81.8269653f); @@ -400,7 +400,7 @@ public static void float4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -424,7 +424,7 @@ public static void float4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_greater_equal_wide_wide() { float4 a0 = float4(-507.9286f, 504.4975f, -385.4345f, -262.323425f); @@ -448,7 +448,7 @@ public static void float4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_greater_equal_wide_scalar() { float4 a0 = float4(465.152161f, -424.886078f, -209.2211f, 58.7798462f); @@ -472,7 +472,7 @@ public static void float4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -496,7 +496,7 @@ public static void float4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_add_wide_wide() { float4 a0 = float4(506.129028f, -501.779816f, 420.084778f, -186.032074f); @@ -520,7 +520,7 @@ public static void float4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_add_wide_scalar() { float4 a0 = float4(-194.514191f, 338.5484f, 246.971375f, 100.510925f); @@ -544,7 +544,7 @@ public static void float4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -568,7 +568,7 @@ public static void float4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_sub_wide_wide() { float4 a0 = float4(160.492249f, 11.223938f, 359.200134f, -498.2283f); @@ -592,7 +592,7 @@ public static void float4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_sub_wide_scalar() { float4 a0 = float4(207.389587f, 248.457764f, -384.8239f, -205.344757f); @@ -616,7 +616,7 @@ public static void float4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -640,7 +640,7 @@ public static void float4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_mul_wide_wide() { float4 a0 = float4(-482.7138f, -407.2935f, 137.700562f, 208.541138f); @@ -664,7 +664,7 @@ public static void float4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_mul_wide_scalar() { float4 a0 = float4(-96.31882f, -277.142273f, -239.93689f, 509.531433f); @@ -688,7 +688,7 @@ public static void float4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -712,7 +712,7 @@ public static void float4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_div_wide_wide() { float4 a0 = float4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f); @@ -736,7 +736,7 @@ public static void float4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_div_wide_scalar() { float4 a0 = float4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f); @@ -760,7 +760,7 @@ public static void float4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -784,7 +784,7 @@ public static void float4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_mod_wide_wide() { float4 a0 = float4(-388.8125f, 181.681213f, -167.078735f, 432.820129f); @@ -808,7 +808,7 @@ public static void float4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_mod_wide_scalar() { float4 a0 = float4(-244.499634f, -211.8193f, -145.926788f, -304.9182f); @@ -832,7 +832,7 @@ public static void float4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -856,7 +856,7 @@ public static void float4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_plus() { float4 a0 = float4(-418.829559f, -405.79895f, -34.04178f, 236.999268f); @@ -876,7 +876,7 @@ public static void float4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_neg() { float4 a0 = float4(148.461731f, -467.122681f, 132.04718f, 183.522644f); @@ -896,7 +896,7 @@ public static void float4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_prefix_inc() { float4 a0 = float4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f); @@ -916,7 +916,7 @@ public static void float4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_postfix_inc() { float4 a0 = float4(-396.669739f, 511.20752f, 249.111267f, -128.817322f); @@ -936,7 +936,7 @@ public static void float4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_prefix_dec() { float4 a0 = float4(123.128723f, 256.84375f, 156.330811f, 461.737427f); @@ -956,7 +956,7 @@ public static void float4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_operator_postfix_dec() { float4 a0 = float4(379.6883f, 302.692871f, -176.07135f, -291.2527f); @@ -976,7 +976,7 @@ public static void float4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_shuffle_result_1() { float4 a = float4(0, 1, 2, 3); @@ -992,7 +992,7 @@ public static void float4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_shuffle_result_2() { float4 a = float4(0, 1, 2, 3); @@ -1016,7 +1016,7 @@ public static void float4_shuffle_result_2() TestUtils.AreEqual(float2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_shuffle_result_3() { float4 a = float4(0, 1, 2, 3); @@ -1040,7 +1040,7 @@ public static void float4_shuffle_result_3() TestUtils.AreEqual(float3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_shuffle_result_4() { float4 a = float4(0, 1, 2, 3); @@ -1064,7 +1064,7 @@ public static void float4_shuffle_result_4() TestUtils.AreEqual(float4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void float4_EqualsObjectOverride() { TestUtils.IsFalse(new float4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs index ef36f471..492a62f9 100644 --- a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_zero() { TestUtils.AreEqual(0.0f, float4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void float4x2_zero() TestUtils.AreEqual(0.0f, float4x2.zero.c1.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_equal_wide_wide() { float4x2 a0 = float4x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f); @@ -52,7 +52,7 @@ public static void float4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_equal_wide_scalar() { float4x2 a0 = float4x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f); @@ -76,7 +76,7 @@ public static void float4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -100,7 +100,7 @@ public static void float4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_not_equal_wide_wide() { float4x2 a0 = float4x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f); @@ -124,7 +124,7 @@ public static void float4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_not_equal_wide_scalar() { float4x2 a0 = float4x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f); @@ -148,7 +148,7 @@ public static void float4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -172,7 +172,7 @@ public static void float4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_less_wide_wide() { float4x2 a0 = float4x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f); @@ -196,7 +196,7 @@ public static void float4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_less_wide_scalar() { float4x2 a0 = float4x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f); @@ -220,7 +220,7 @@ public static void float4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -244,7 +244,7 @@ public static void float4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_greater_wide_wide() { float4x2 a0 = float4x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f); @@ -268,7 +268,7 @@ public static void float4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_greater_wide_scalar() { float4x2 a0 = float4x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f); @@ -292,7 +292,7 @@ public static void float4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -316,7 +316,7 @@ public static void float4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_less_equal_wide_wide() { float4x2 a0 = float4x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f); @@ -340,7 +340,7 @@ public static void float4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_less_equal_wide_scalar() { float4x2 a0 = float4x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f); @@ -364,7 +364,7 @@ public static void float4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -388,7 +388,7 @@ public static void float4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_greater_equal_wide_wide() { float4x2 a0 = float4x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f); @@ -412,7 +412,7 @@ public static void float4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_greater_equal_wide_scalar() { float4x2 a0 = float4x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f); @@ -436,7 +436,7 @@ public static void float4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -460,7 +460,7 @@ public static void float4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_add_wide_wide() { float4x2 a0 = float4x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f); @@ -484,7 +484,7 @@ public static void float4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_add_wide_scalar() { float4x2 a0 = float4x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f); @@ -508,7 +508,7 @@ public static void float4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -532,7 +532,7 @@ public static void float4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_sub_wide_wide() { float4x2 a0 = float4x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f); @@ -556,7 +556,7 @@ public static void float4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_sub_wide_scalar() { float4x2 a0 = float4x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f); @@ -580,7 +580,7 @@ public static void float4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -604,7 +604,7 @@ public static void float4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_mul_wide_wide() { float4x2 a0 = float4x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f); @@ -628,7 +628,7 @@ public static void float4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_mul_wide_scalar() { float4x2 a0 = float4x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f); @@ -652,7 +652,7 @@ public static void float4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -676,7 +676,7 @@ public static void float4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_div_wide_wide() { float4x2 a0 = float4x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f); @@ -700,7 +700,7 @@ public static void float4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_div_wide_scalar() { float4x2 a0 = float4x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f); @@ -724,7 +724,7 @@ public static void float4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -748,7 +748,7 @@ public static void float4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_mod_wide_wide() { float4x2 a0 = float4x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f); @@ -772,7 +772,7 @@ public static void float4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_mod_wide_scalar() { float4x2 a0 = float4x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f); @@ -796,7 +796,7 @@ public static void float4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -820,7 +820,7 @@ public static void float4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_plus() { float4x2 a0 = float4x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f); @@ -840,7 +840,7 @@ public static void float4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_neg() { float4x2 a0 = float4x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f); @@ -860,7 +860,7 @@ public static void float4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_prefix_inc() { float4x2 a0 = float4x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f); @@ -880,7 +880,7 @@ public static void float4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_postfix_inc() { float4x2 a0 = float4x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f); @@ -900,7 +900,7 @@ public static void float4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_prefix_dec() { float4x2 a0 = float4x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f); @@ -920,7 +920,7 @@ public static void float4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x2_operator_postfix_dec() { float4x2 a0 = float4x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f); @@ -940,7 +940,7 @@ public static void float4x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float4x2_EqualsObjectOverride() { TestUtils.IsFalse(new float4x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs index f14618d1..06fb08a0 100644 --- a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_zero() { TestUtils.AreEqual(0.0f, float4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void float4x3_zero() TestUtils.AreEqual(0.0f, float4x3.zero.c2.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_equal_wide_wide() { float4x3 a0 = float4x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f); @@ -56,7 +56,7 @@ public static void float4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_equal_wide_scalar() { float4x3 a0 = float4x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f); @@ -80,7 +80,7 @@ public static void float4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -104,7 +104,7 @@ public static void float4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_not_equal_wide_wide() { float4x3 a0 = float4x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f); @@ -128,7 +128,7 @@ public static void float4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_not_equal_wide_scalar() { float4x3 a0 = float4x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f); @@ -152,7 +152,7 @@ public static void float4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -176,7 +176,7 @@ public static void float4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_less_wide_wide() { float4x3 a0 = float4x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f); @@ -200,7 +200,7 @@ public static void float4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_less_wide_scalar() { float4x3 a0 = float4x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f); @@ -224,7 +224,7 @@ public static void float4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -248,7 +248,7 @@ public static void float4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_greater_wide_wide() { float4x3 a0 = float4x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f); @@ -272,7 +272,7 @@ public static void float4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_greater_wide_scalar() { float4x3 a0 = float4x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f); @@ -296,7 +296,7 @@ public static void float4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -320,7 +320,7 @@ public static void float4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_less_equal_wide_wide() { float4x3 a0 = float4x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f); @@ -344,7 +344,7 @@ public static void float4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_less_equal_wide_scalar() { float4x3 a0 = float4x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f); @@ -368,7 +368,7 @@ public static void float4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -392,7 +392,7 @@ public static void float4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_greater_equal_wide_wide() { float4x3 a0 = float4x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f); @@ -416,7 +416,7 @@ public static void float4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_greater_equal_wide_scalar() { float4x3 a0 = float4x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f); @@ -440,7 +440,7 @@ public static void float4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -464,7 +464,7 @@ public static void float4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_add_wide_wide() { float4x3 a0 = float4x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f); @@ -488,7 +488,7 @@ public static void float4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_add_wide_scalar() { float4x3 a0 = float4x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f); @@ -512,7 +512,7 @@ public static void float4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -536,7 +536,7 @@ public static void float4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_sub_wide_wide() { float4x3 a0 = float4x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f); @@ -560,7 +560,7 @@ public static void float4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_sub_wide_scalar() { float4x3 a0 = float4x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f); @@ -584,7 +584,7 @@ public static void float4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -608,7 +608,7 @@ public static void float4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_mul_wide_wide() { float4x3 a0 = float4x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f); @@ -632,7 +632,7 @@ public static void float4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_mul_wide_scalar() { float4x3 a0 = float4x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f); @@ -656,7 +656,7 @@ public static void float4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -680,7 +680,7 @@ public static void float4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_div_wide_wide() { float4x3 a0 = float4x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f); @@ -704,7 +704,7 @@ public static void float4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_div_wide_scalar() { float4x3 a0 = float4x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f); @@ -728,7 +728,7 @@ public static void float4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -752,7 +752,7 @@ public static void float4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_mod_wide_wide() { float4x3 a0 = float4x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f); @@ -776,7 +776,7 @@ public static void float4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_mod_wide_scalar() { float4x3 a0 = float4x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f); @@ -800,7 +800,7 @@ public static void float4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -824,7 +824,7 @@ public static void float4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_plus() { float4x3 a0 = float4x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f); @@ -844,7 +844,7 @@ public static void float4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_neg() { float4x3 a0 = float4x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f); @@ -864,7 +864,7 @@ public static void float4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_prefix_inc() { float4x3 a0 = float4x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f); @@ -884,7 +884,7 @@ public static void float4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_postfix_inc() { float4x3 a0 = float4x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f); @@ -904,7 +904,7 @@ public static void float4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_prefix_dec() { float4x3 a0 = float4x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f); @@ -924,7 +924,7 @@ public static void float4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x3_operator_postfix_dec() { float4x3 a0 = float4x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f); @@ -944,7 +944,7 @@ public static void float4x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float4x3_EqualsObjectOverride() { TestUtils.IsFalse(new float4x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs index cc444939..d7c82665 100644 --- a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_zero() { TestUtils.AreEqual(0.0f, float4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void float4x4_zero() TestUtils.AreEqual(0.0f, float4x4.zero.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_identity() { TestUtils.AreEqual(1.0f, float4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void float4x4_identity() TestUtils.AreEqual(1.0f, float4x4.identity.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_equal_wide_wide() { float4x4 a0 = float4x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f, 109.6344f, 462.6903f, -335.38147f, 357.2345f); @@ -81,7 +81,7 @@ public static void float4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_equal_wide_scalar() { float4x4 a0 = float4x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f, -172.035309f, 455.400024f, -11.3389893f, 363.938232f); @@ -105,7 +105,7 @@ public static void float4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -129,7 +129,7 @@ public static void float4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_not_equal_wide_wide() { float4x4 a0 = float4x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f, 65.66205f, 102.787781f, 172.930054f, 26.6210327f); @@ -153,7 +153,7 @@ public static void float4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_not_equal_wide_scalar() { float4x4 a0 = float4x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f, -269.805725f, 299.654236f, -71.7509155f, -432.755737f); @@ -177,7 +177,7 @@ public static void float4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -201,7 +201,7 @@ public static void float4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_less_wide_wide() { float4x4 a0 = float4x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f, -111.129944f, 70.00549f, 448.1983f, -419.987122f); @@ -225,7 +225,7 @@ public static void float4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_less_wide_scalar() { float4x4 a0 = float4x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f, 373.549683f, 398.523682f, 105.030151f, -58.0108948f); @@ -249,7 +249,7 @@ public static void float4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -273,7 +273,7 @@ public static void float4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_greater_wide_wide() { float4x4 a0 = float4x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f, 455.85144f, 144.706909f, 63.9320068f, -285.683044f); @@ -297,7 +297,7 @@ public static void float4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_greater_wide_scalar() { float4x4 a0 = float4x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f, 370.279175f, -413.7014f, -356.592346f, -353.0313f); @@ -321,7 +321,7 @@ public static void float4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -345,7 +345,7 @@ public static void float4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_less_equal_wide_wide() { float4x4 a0 = float4x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f, 149.736511f, -418.8867f, -197.502533f, -88.2055054f); @@ -369,7 +369,7 @@ public static void float4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_less_equal_wide_scalar() { float4x4 a0 = float4x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f, -264.9378f, 82.2583f, 11.2460327f, 424.704041f); @@ -393,7 +393,7 @@ public static void float4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -417,7 +417,7 @@ public static void float4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_greater_equal_wide_wide() { float4x4 a0 = float4x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f, -309.570221f, -136.022491f, 280.736267f, -96.99588f); @@ -441,7 +441,7 @@ public static void float4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_greater_equal_wide_scalar() { float4x4 a0 = float4x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f, -36.9942932f, 494.8203f, -164.973938f, -466.1201f); @@ -465,7 +465,7 @@ public static void float4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -489,7 +489,7 @@ public static void float4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_add_wide_wide() { float4x4 a0 = float4x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f, 69.19568f, -177.957336f, 299.604126f, 340.704834f); @@ -513,7 +513,7 @@ public static void float4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_add_wide_scalar() { float4x4 a0 = float4x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f, -188.265015f, -213.526733f, -267.7843f, 189.259949f); @@ -537,7 +537,7 @@ public static void float4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -561,7 +561,7 @@ public static void float4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_sub_wide_wide() { float4x4 a0 = float4x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f, 24.8754272f, 366.614441f, -107.374146f, -219.008148f); @@ -585,7 +585,7 @@ public static void float4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_sub_wide_scalar() { float4x4 a0 = float4x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f, 349.397766f, 439.077271f, 490.2223f, 195.024048f); @@ -609,7 +609,7 @@ public static void float4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -633,7 +633,7 @@ public static void float4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_mul_wide_wide() { float4x4 a0 = float4x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f, -262.682556f, -379.262756f, -374.090576f, 481.4474f); @@ -657,7 +657,7 @@ public static void float4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_mul_wide_scalar() { float4x4 a0 = float4x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f, -207.3501f, -383.9396f, -31.4252319f, 42.6761475f); @@ -681,7 +681,7 @@ public static void float4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -705,7 +705,7 @@ public static void float4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_div_wide_wide() { float4x4 a0 = float4x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f, -416.226135f, -450.0192f, -273.497437f, -286.908173f); @@ -729,7 +729,7 @@ public static void float4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_div_wide_scalar() { float4x4 a0 = float4x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f, -205.033813f, 481.738159f, 464.479065f, -293.4635f); @@ -753,7 +753,7 @@ public static void float4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -777,7 +777,7 @@ public static void float4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_mod_wide_wide() { float4x4 a0 = float4x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f, -124.033722f, 259.274f, -274.358459f, -140.030792f); @@ -801,7 +801,7 @@ public static void float4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_mod_wide_scalar() { float4x4 a0 = float4x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f, -355.846863f, 259.378f, -330.871948f, -284.343567f); @@ -825,7 +825,7 @@ public static void float4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -849,7 +849,7 @@ public static void float4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_plus() { float4x4 a0 = float4x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f, -170.746521f, 439.5594f, -478.7494f, 116.400757f); @@ -869,7 +869,7 @@ public static void float4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_neg() { float4x4 a0 = float4x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f, 466.441528f, 171.902466f, -280.558319f, -78.857605f); @@ -889,7 +889,7 @@ public static void float4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_prefix_inc() { float4x4 a0 = float4x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f, 243.546936f, 46.1920166f, -41.4972839f, 299.1855f); @@ -909,7 +909,7 @@ public static void float4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_postfix_inc() { float4x4 a0 = float4x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f, 128.5304f, 73.15558f, -60.1323853f, -446.229767f); @@ -929,7 +929,7 @@ public static void float4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_prefix_dec() { float4x4 a0 = float4x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f, -363.0755f, -22.0289612f, 248.7901f, 168.095032f); @@ -949,7 +949,7 @@ public static void float4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_operator_postfix_dec() { float4x4 a0 = float4x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f, -200.304291f, -445.026947f, 407.420349f, 327.670349f); @@ -969,7 +969,7 @@ public static void float4x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCase] + [TestCase /* For player builds */] public static void float4x4_EqualsObjectOverride() { TestUtils.IsFalse(new float4x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestHalf.cs b/src/Tests/Tests/Shared/TestHalf.cs index 7cd3e330..301e06d2 100644 --- a/src/Tests/Tests/Shared/TestHalf.cs +++ b/src/Tests/Tests/Shared/TestHalf.cs @@ -8,20 +8,20 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestHalf { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_zero() { TestUtils.AreEqual(0x0000, half.zero.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_zero() { TestUtils.AreEqual(0x0000, half2.zero.x.value); TestUtils.AreEqual(0x0000, half2.zero.y.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_zero() { TestUtils.AreEqual(0x0000, half3.zero.x.value); @@ -29,7 +29,7 @@ public static void half3_zero() TestUtils.AreEqual(0x0000, half3.zero.z.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_zero() { TestUtils.AreEqual(0x0000, half4.zero.x.value); @@ -38,7 +38,7 @@ public static void half4_zero() TestUtils.AreEqual(0x0000, half4.zero.w.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_from_float_construction() { TestUtils.AreEqual(0x0000, half(0.0f).value); @@ -58,14 +58,14 @@ public static void half_from_float_construction() TestUtils.AreEqual(0xFC00, half(float.NegativeInfinity).value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half_from_float_construction_signed_zero() { TestUtils.AreEqual(0x8000, half(TestUtils.SignedFloatZero()).value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_from_float2_construction() { half2 h0 = half2(float2(0.0f, 2.98e-08f)); @@ -89,7 +89,7 @@ public static void half2_from_float2_construction() TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half2_from_float2_construction_signed_zero() { @@ -97,7 +97,7 @@ public static void half2_from_float2_construction_signed_zero() TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_from_float3_construction() { half3 h0 = half3(float3(0.0f, 2.98e-08f, 5.96046448e-08f)); @@ -114,7 +114,7 @@ public static void half3_from_float3_construction() TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half3_from_float3_construction_signed_zero() { @@ -122,7 +122,7 @@ public static void half3_from_float3_construction_signed_zero() TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_from_float4_construction() { half4 h0 = half4(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f)); @@ -136,7 +136,7 @@ public static void half4_from_float4_construction() TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half4_from_float4_construction_signed_zero() { @@ -145,7 +145,7 @@ public static void half4_from_float4_construction_signed_zero() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_from_double_construction() { TestUtils.AreEqual(0x0000, half(0.0).value); @@ -165,14 +165,14 @@ public static void half_from_double_construction() TestUtils.AreEqual(0xFC00, half(double.NegativeInfinity).value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half_from_double_construction_signed_zero() { TestUtils.AreEqual(0x8000, half(TestUtils.SignedDoubleZero()).value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_from_double2_construction() { half2 h0 = half2(double2(0.0, 2.98e-08)); @@ -196,7 +196,7 @@ public static void half2_from_double2_construction() TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half2_from_double2_construction_signed_zero() { @@ -204,7 +204,7 @@ public static void half2_from_double2_construction_signed_zero() TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_from_double3_construction() { half3 h0 = half3(double3(0.0, 2.98e-08, 5.96046448e-08)); @@ -221,7 +221,7 @@ public static void half3_from_double3_construction() TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half3_from_double3_construction_signed_zero() { @@ -229,7 +229,7 @@ public static void half3_from_double3_construction_signed_zero() TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_from_double4_construction() { half4 h0 = half4(double4(0.0, 2.98e-08, 5.96046448e-08, 123.4)); @@ -243,7 +243,7 @@ public static void half4_from_double4_construction() TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half4_from_double4_construction_signed_zero() { @@ -251,7 +251,7 @@ public static void half4_from_double4_construction_signed_zero() TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_to_float() { TestUtils.AreEqual(0x00000000, asuint(new half { value = 0x0000 })); @@ -269,7 +269,7 @@ public static void half_to_float() TestUtils.AreEqual(true, isnan(new half { value = 0xFC01 })); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_to_float2() { half2 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; @@ -293,7 +293,7 @@ public static void half2_to_float2() TestUtils.AreEqual(true, all(isnan(h7))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_to_float3() { half3 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; @@ -313,7 +313,7 @@ public static void half3_to_float3() TestUtils.AreEqual(true, all(isnan(h5))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_to_float4() { half4 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; h0.w.value = 0x7BFF; @@ -334,7 +334,7 @@ public static void half4_to_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_to_double() { TestUtils.AreEqual(0x0000000000000000u, asulong((double)new half { value = 0x0000 })); @@ -353,14 +353,14 @@ public static void half_to_double() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_from_float_explicit_conversion() { half h = (half)123.4f; TestUtils.AreEqual(0x57B6, h.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_from_float2_explicit_conversion() { half2 h = (half2)float2(123.4f, 5.96046448e-08f); @@ -368,7 +368,7 @@ public static void half2_from_float2_explicit_conversion() TestUtils.AreEqual(0x0001, h.y.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_from_float3_explicit_conversion() { half3 h = (half3)float3(123.4f, 5.96046448e-08f, -65504.0f); @@ -377,7 +377,7 @@ public static void half3_from_float3_explicit_conversion() TestUtils.AreEqual(0xFBFF, h.z.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_from_float4_explicit_conversion() { half4 h = (half4)float4(123.4f, 5.96046448e-08f, -65504.0f, float.PositiveInfinity); @@ -387,7 +387,7 @@ public static void half4_from_float4_explicit_conversion() TestUtils.AreEqual(0x7C00, h.w.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_from_double_explicit_conversion() { half h = (half)123.4; @@ -395,7 +395,7 @@ public static void half_from_double_explicit_conversion() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_to_float_implicit_conversion() { half h; h.value = 0x0203; @@ -403,7 +403,7 @@ public static void half_to_float_implicit_conversion() TestUtils.AreEqual(0x3800C000, asuint(f)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_to_float2_implicit_conversion() { half2 h; h.x.value = 0x0203; h.y.value = 0x8203; @@ -412,7 +412,7 @@ public static void half2_to_float2_implicit_conversion() TestUtils.AreEqual(0xB800C000, asuint(f.y)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_to_float3_implicit_conversion() { half3 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; @@ -422,7 +422,7 @@ public static void half3_to_float3_implicit_conversion() TestUtils.AreEqual(0x477FE000, asuint(f.z)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_to_float4_implicit_conversion() { half4 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; h.w.value = 0x7C00; @@ -433,7 +433,7 @@ public static void half4_to_float4_implicit_conversion() TestUtils.AreEqual(0x7F800000, asuint(f.w)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_to_double_implicit_conversion() { half h; h.value = 0x0203; @@ -442,33 +442,33 @@ public static void half_to_double_implicit_conversion() TestUtils.AreEqual(0x3F00180000000000u, asulong(f)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_minvalue() { half min = new half(half.MinValue); TestUtils.AreEqual(0xfbff, min.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_maxvalue() { half max = new half(half.MaxValue); TestUtils.AreEqual(0x7bff, max.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_minvalueashalf() { TestUtils.AreEqual(0xfbff, half.MinValueAsHalf.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half_maxvalueashalf() { TestUtils.AreEqual(0x7bff, half.MaxValueAsHalf.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_minvalue() { half2 min = half.MinValueAsHalf; @@ -476,7 +476,7 @@ public static void half2_minvalue() TestUtils.AreEqual(0xfbff, min.y.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half2_maxvalue() { half2 max = half.MaxValueAsHalf; @@ -484,7 +484,7 @@ public static void half2_maxvalue() TestUtils.AreEqual(0x7bff, max.y.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_minvalue() { half3 min = half.MinValueAsHalf; @@ -493,7 +493,7 @@ public static void half3_minvalue() TestUtils.AreEqual(0xfbff, min.z.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half3_maxvalue() { half3 max = half.MaxValueAsHalf; @@ -502,7 +502,7 @@ public static void half3_maxvalue() TestUtils.AreEqual(0x7bff, max.z.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_minvalue() { half4 min = half.MinValueAsHalf; @@ -512,7 +512,7 @@ public static void half4_minvalue() TestUtils.AreEqual(0xfbff, min.w.value); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void half4_maxvalue() { half4 max = half.MaxValueAsHalf; diff --git a/src/Tests/Tests/Shared/TestInt2.gen.cs b/src/Tests/Tests/Shared/TestInt2.gen.cs index 78c07923..6196c993 100644 --- a/src/Tests/Tests/Shared/TestInt2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_zero() { TestUtils.AreEqual(0, int2.zero.x); TestUtils.AreEqual(0, int2.zero.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_constructor() { int2 a = new int2(1, 2); @@ -30,7 +30,7 @@ public static void int2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_scalar_constructor() { int2 a = new int2(17); @@ -38,7 +38,7 @@ public static void int2_scalar_constructor() TestUtils.AreEqual(17, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_static_constructor() { int2 a = int2(1, 2); @@ -46,7 +46,7 @@ public static void int2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_static_scalar_constructor() { int2 a = int2(17); @@ -54,7 +54,7 @@ public static void int2_static_scalar_constructor() TestUtils.AreEqual(17, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_equal_wide_wide() { int2 a0 = int2(2105871082, 35218899); @@ -78,7 +78,7 @@ public static void int2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_equal_wide_scalar() { int2 a0 = int2(437822262, 2020661134); @@ -102,7 +102,7 @@ public static void int2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -126,7 +126,7 @@ public static void int2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_not_equal_wide_wide() { int2 a0 = int2(1977284100, 1293292704); @@ -150,7 +150,7 @@ public static void int2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_not_equal_wide_scalar() { int2 a0 = int2(1038269360, 1427812625); @@ -174,7 +174,7 @@ public static void int2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -198,7 +198,7 @@ public static void int2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_less_wide_wide() { int2 a0 = int2(1486550609, 1779244308); @@ -222,7 +222,7 @@ public static void int2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_less_wide_scalar() { int2 a0 = int2(796797557, 670113454); @@ -246,7 +246,7 @@ public static void int2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_less_scalar_wide() { int a0 = (186400299); @@ -270,7 +270,7 @@ public static void int2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_greater_wide_wide() { int2 a0 = int2(2087717754, 1725569452); @@ -294,7 +294,7 @@ public static void int2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_greater_wide_scalar() { int2 a0 = int2(1208626274, 239697208); @@ -318,7 +318,7 @@ public static void int2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -342,7 +342,7 @@ public static void int2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_less_equal_wide_wide() { int2 a0 = int2(154092149, 1515170149); @@ -366,7 +366,7 @@ public static void int2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_less_equal_wide_scalar() { int2 a0 = int2(1479531977, 1427983411); @@ -390,7 +390,7 @@ public static void int2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -414,7 +414,7 @@ public static void int2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_greater_equal_wide_wide() { int2 a0 = int2(8538378, 2131749726); @@ -438,7 +438,7 @@ public static void int2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_greater_equal_wide_scalar() { int2 a0 = int2(2049236663, 182691143); @@ -462,7 +462,7 @@ public static void int2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -486,7 +486,7 @@ public static void int2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_add_wide_wide() { int2 a0 = int2(2135171378, 21433296); @@ -510,7 +510,7 @@ public static void int2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_add_wide_scalar() { int2 a0 = int2(665815972, 1783729250); @@ -534,7 +534,7 @@ public static void int2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_add_scalar_wide() { int a0 = (359966320); @@ -558,7 +558,7 @@ public static void int2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_sub_wide_wide() { int2 a0 = int2(1410318491, 1097280168); @@ -582,7 +582,7 @@ public static void int2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_sub_wide_scalar() { int2 a0 = int2(1508669340, 1594795463); @@ -606,7 +606,7 @@ public static void int2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -630,7 +630,7 @@ public static void int2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_mul_wide_wide() { int2 a0 = int2(61417577, 219585476); @@ -654,7 +654,7 @@ public static void int2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_mul_wide_scalar() { int2 a0 = int2(871746615, 492532311); @@ -678,7 +678,7 @@ public static void int2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -702,7 +702,7 @@ public static void int2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_div_wide_wide() { int2 a0 = int2(333171510, 858154903); @@ -726,7 +726,7 @@ public static void int2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_div_wide_scalar() { int2 a0 = int2(1433072926, 1073958635); @@ -750,7 +750,7 @@ public static void int2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_div_scalar_wide() { int a0 = (519165704); @@ -774,7 +774,7 @@ public static void int2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_mod_wide_wide() { int2 a0 = int2(258342924, 1454754891); @@ -798,7 +798,7 @@ public static void int2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_mod_wide_scalar() { int2 a0 = int2(560988938, 629524514); @@ -822,7 +822,7 @@ public static void int2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -846,7 +846,7 @@ public static void int2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_plus() { int2 a0 = int2(195392567, 222719748); @@ -866,7 +866,7 @@ public static void int2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_neg() { int2 a0 = int2(1385088677, 94114564); @@ -886,7 +886,7 @@ public static void int2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_prefix_inc() { int2 a0 = int2(780471723, 954741756); @@ -906,7 +906,7 @@ public static void int2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_postfix_inc() { int2 a0 = int2(241865086, 2145821641); @@ -926,7 +926,7 @@ public static void int2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_prefix_dec() { int2 a0 = int2(1331961415, 1612382200); @@ -946,7 +946,7 @@ public static void int2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_postfix_dec() { int2 a0 = int2(1870005937, 1708534798); @@ -966,7 +966,7 @@ public static void int2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_and_wide_wide() { int2 a0 = int2(1055241304, 859321394); @@ -990,7 +990,7 @@ public static void int2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_and_wide_scalar() { int2 a0 = int2(1513158868, 284695609); @@ -1014,7 +1014,7 @@ public static void int2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1038,7 +1038,7 @@ public static void int2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_or_wide_wide() { int2 a0 = int2(1920951869, 1750772852); @@ -1062,7 +1062,7 @@ public static void int2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_or_wide_scalar() { int2 a0 = int2(1295304853, 1307252624); @@ -1086,7 +1086,7 @@ public static void int2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1110,7 +1110,7 @@ public static void int2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_xor_wide_wide() { int2 a0 = int2(1843655608, 362425681); @@ -1134,7 +1134,7 @@ public static void int2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_xor_wide_scalar() { int2 a0 = int2(169345668, 176087064); @@ -1158,7 +1158,7 @@ public static void int2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1182,7 +1182,7 @@ public static void int2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_left_shift() { int2 a0 = int2(1129100049, 829482269); @@ -1206,7 +1206,7 @@ public static void int2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_right_shift() { int2 a0 = int2(809126085, 908563670); @@ -1230,7 +1230,7 @@ public static void int2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_operator_bitwise_not() { int2 a0 = int2(111796841, 603562399); @@ -1250,7 +1250,7 @@ public static void int2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_shuffle_result_1() { int2 a = int2(0, 1); @@ -1262,7 +1262,7 @@ public static void int2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_shuffle_result_2() { int2 a = int2(0, 1); @@ -1286,7 +1286,7 @@ public static void int2_shuffle_result_2() TestUtils.AreEqual(int2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_shuffle_result_3() { int2 a = int2(0, 1); @@ -1310,7 +1310,7 @@ public static void int2_shuffle_result_3() TestUtils.AreEqual(int3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_shuffle_result_4() { int2 a = int2(0, 1); @@ -1334,7 +1334,7 @@ public static void int2_shuffle_result_4() TestUtils.AreEqual(int4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX)); } - [TestCase] + [TestCase /* For player builds */] public static void int2_EqualsObjectOverride() { TestUtils.IsFalse(new int2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt2x2.gen.cs b/src/Tests/Tests/Shared/TestInt2x2.gen.cs index 517c4586..a99dd57e 100644 --- a/src/Tests/Tests/Shared/TestInt2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_zero() { TestUtils.AreEqual(0, int2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void int2x2_zero() TestUtils.AreEqual(0, int2x2.zero.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_identity() { TestUtils.AreEqual(1, int2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void int2x2_identity() TestUtils.AreEqual(1, int2x2.identity.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_equal_wide_wide() { int2x2 a0 = int2x2(2105871082, 35218899, 1550755093, 764676020); @@ -57,7 +57,7 @@ public static void int2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_equal_wide_scalar() { int2x2 a0 = int2x2(437822262, 2020661134, 541786900, 853113810); @@ -81,7 +81,7 @@ public static void int2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -105,7 +105,7 @@ public static void int2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_not_equal_wide_wide() { int2x2 a0 = int2x2(1977284100, 1293292704, 1547283851, 422428953); @@ -129,7 +129,7 @@ public static void int2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_not_equal_wide_scalar() { int2x2 a0 = int2x2(1038269360, 1427812625, 103361237, 1347017023); @@ -153,7 +153,7 @@ public static void int2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -177,7 +177,7 @@ public static void int2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_less_wide_wide() { int2x2 a0 = int2x2(1486550609, 1779244308, 1602148045, 1614085440); @@ -201,7 +201,7 @@ public static void int2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_less_wide_scalar() { int2x2 a0 = int2x2(796797557, 670113454, 933579492, 278884514); @@ -225,7 +225,7 @@ public static void int2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_less_scalar_wide() { int a0 = (186400299); @@ -249,7 +249,7 @@ public static void int2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_greater_wide_wide() { int2x2 a0 = int2x2(2087717754, 1725569452, 1298066182, 1693943616); @@ -273,7 +273,7 @@ public static void int2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_greater_wide_scalar() { int2x2 a0 = int2x2(1208626274, 239697208, 1979453345, 1253474001); @@ -297,7 +297,7 @@ public static void int2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -321,7 +321,7 @@ public static void int2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_less_equal_wide_wide() { int2x2 a0 = int2x2(154092149, 1515170149, 1083970332, 785807178); @@ -345,7 +345,7 @@ public static void int2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_less_equal_wide_scalar() { int2x2 a0 = int2x2(1479531977, 1427983411, 415250630, 1245345407); @@ -369,7 +369,7 @@ public static void int2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -393,7 +393,7 @@ public static void int2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_greater_equal_wide_wide() { int2x2 a0 = int2x2(8538378, 2131749726, 265427108, 523609761); @@ -417,7 +417,7 @@ public static void int2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_greater_equal_wide_scalar() { int2x2 a0 = int2x2(2049236663, 182691143, 634973382, 1197012109); @@ -441,7 +441,7 @@ public static void int2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -465,7 +465,7 @@ public static void int2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_add_wide_wide() { int2x2 a0 = int2x2(2135171378, 21433296, 1954723494, 683604307); @@ -489,7 +489,7 @@ public static void int2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_add_wide_scalar() { int2x2 a0 = int2x2(665815972, 1783729250, 1591678394, 1284528538); @@ -513,7 +513,7 @@ public static void int2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_add_scalar_wide() { int a0 = (359966320); @@ -537,7 +537,7 @@ public static void int2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_sub_wide_wide() { int2x2 a0 = int2x2(1410318491, 1097280168, 1827039044, 28881338); @@ -561,7 +561,7 @@ public static void int2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_sub_wide_scalar() { int2x2 a0 = int2x2(1508669340, 1594795463, 266707545, 643102647); @@ -585,7 +585,7 @@ public static void int2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -609,7 +609,7 @@ public static void int2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_mul_wide_wide() { int2x2 a0 = int2x2(61417577, 219585476, 1362520891, 1511084277); @@ -633,7 +633,7 @@ public static void int2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_mul_wide_scalar() { int2x2 a0 = int2x2(871746615, 492532311, 570557670, 2142306629); @@ -657,7 +657,7 @@ public static void int2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -681,7 +681,7 @@ public static void int2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_div_wide_wide() { int2x2 a0 = int2x2(333171510, 858154903, 1181365836, 671357749); @@ -705,7 +705,7 @@ public static void int2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_div_wide_scalar() { int2x2 a0 = int2x2(1433072926, 1073958635, 1195142312, 536596719); @@ -729,7 +729,7 @@ public static void int2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_div_scalar_wide() { int a0 = (519165704); @@ -753,7 +753,7 @@ public static void int2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_mod_wide_wide() { int2x2 a0 = int2x2(258342924, 1454754891, 723352342, 1981431473); @@ -777,7 +777,7 @@ public static void int2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_mod_wide_scalar() { int2x2 a0 = int2x2(560988938, 629524514, 767711194, 434281967); @@ -801,7 +801,7 @@ public static void int2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -825,7 +825,7 @@ public static void int2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_plus() { int2x2 a0 = int2x2(195392567, 222719748, 1002351013, 1570765263); @@ -845,7 +845,7 @@ public static void int2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_neg() { int2x2 a0 = int2x2(1385088677, 94114564, 1350664872, 1458616659); @@ -865,7 +865,7 @@ public static void int2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_prefix_inc() { int2x2 a0 = int2x2(780471723, 954741756, 272723451, 2142862245); @@ -885,7 +885,7 @@ public static void int2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_postfix_inc() { int2x2 a0 = int2x2(241865086, 2145821641, 1596166022, 803592338); @@ -905,7 +905,7 @@ public static void int2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_prefix_dec() { int2x2 a0 = int2x2(1331961415, 1612382200, 1401591249, 2042075388); @@ -925,7 +925,7 @@ public static void int2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_postfix_dec() { int2x2 a0 = int2x2(1870005937, 1708534798, 704493460, 462940703); @@ -945,7 +945,7 @@ public static void int2x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_and_wide_wide() { int2x2 a0 = int2x2(1055241304, 859321394, 1088358961, 2090949513); @@ -969,7 +969,7 @@ public static void int2x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_and_wide_scalar() { int2x2 a0 = int2x2(1513158868, 284695609, 734595037, 1566510707); @@ -993,7 +993,7 @@ public static void int2x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1017,7 +1017,7 @@ public static void int2x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_or_wide_wide() { int2x2 a0 = int2x2(1920951869, 1750772852, 1420019191, 732977093); @@ -1041,7 +1041,7 @@ public static void int2x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_or_wide_scalar() { int2x2 a0 = int2x2(1295304853, 1307252624, 350194630, 1128063578); @@ -1065,7 +1065,7 @@ public static void int2x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1089,7 +1089,7 @@ public static void int2x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_xor_wide_wide() { int2x2 a0 = int2x2(1843655608, 362425681, 640805534, 1342040268); @@ -1113,7 +1113,7 @@ public static void int2x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_xor_wide_scalar() { int2x2 a0 = int2x2(169345668, 176087064, 2084362901, 1663924004); @@ -1137,7 +1137,7 @@ public static void int2x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1161,7 +1161,7 @@ public static void int2x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_left_shift() { int2x2 a0 = int2x2(1129100049, 829482269, 1571297368, 443753193); @@ -1185,7 +1185,7 @@ public static void int2x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_right_shift() { int2x2 a0 = int2x2(809126085, 908563670, 763568837, 1986717290); @@ -1209,7 +1209,7 @@ public static void int2x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x2_operator_bitwise_not() { int2x2 a0 = int2x2(111796841, 603562399, 745091931, 853183268); @@ -1229,7 +1229,7 @@ public static void int2x2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int2x2_EqualsObjectOverride() { TestUtils.IsFalse(new int2x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt2x3.gen.cs b/src/Tests/Tests/Shared/TestInt2x3.gen.cs index e6b88941..95b713de 100644 --- a/src/Tests/Tests/Shared/TestInt2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_zero() { TestUtils.AreEqual(0, int2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void int2x3_zero() TestUtils.AreEqual(0, int2x3.zero.c2.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_equal_wide_wide() { int2x3 a0 = int2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void int2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_equal_wide_scalar() { int2x3 a0 = int2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void int2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -98,7 +98,7 @@ public static void int2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_not_equal_wide_wide() { int2x3 a0 = int2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void int2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_not_equal_wide_scalar() { int2x3 a0 = int2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void int2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -170,7 +170,7 @@ public static void int2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_less_wide_wide() { int2x3 a0 = int2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void int2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_less_wide_scalar() { int2x3 a0 = int2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void int2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_less_scalar_wide() { int a0 = (186400299); @@ -242,7 +242,7 @@ public static void int2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_greater_wide_wide() { int2x3 a0 = int2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void int2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_greater_wide_scalar() { int2x3 a0 = int2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void int2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -314,7 +314,7 @@ public static void int2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_less_equal_wide_wide() { int2x3 a0 = int2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void int2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_less_equal_wide_scalar() { int2x3 a0 = int2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void int2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -386,7 +386,7 @@ public static void int2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_greater_equal_wide_wide() { int2x3 a0 = int2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void int2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_greater_equal_wide_scalar() { int2x3 a0 = int2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void int2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -458,7 +458,7 @@ public static void int2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_add_wide_wide() { int2x3 a0 = int2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void int2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_add_wide_scalar() { int2x3 a0 = int2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void int2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_add_scalar_wide() { int a0 = (359966320); @@ -530,7 +530,7 @@ public static void int2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_sub_wide_wide() { int2x3 a0 = int2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void int2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_sub_wide_scalar() { int2x3 a0 = int2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void int2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -602,7 +602,7 @@ public static void int2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_mul_wide_wide() { int2x3 a0 = int2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void int2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_mul_wide_scalar() { int2x3 a0 = int2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void int2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -674,7 +674,7 @@ public static void int2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_div_wide_wide() { int2x3 a0 = int2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void int2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_div_wide_scalar() { int2x3 a0 = int2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void int2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_div_scalar_wide() { int a0 = (519165704); @@ -746,7 +746,7 @@ public static void int2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_mod_wide_wide() { int2x3 a0 = int2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void int2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_mod_wide_scalar() { int2x3 a0 = int2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void int2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -818,7 +818,7 @@ public static void int2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_plus() { int2x3 a0 = int2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void int2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_neg() { int2x3 a0 = int2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void int2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_prefix_inc() { int2x3 a0 = int2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void int2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_postfix_inc() { int2x3 a0 = int2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void int2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_prefix_dec() { int2x3 a0 = int2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void int2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_postfix_dec() { int2x3 a0 = int2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void int2x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_and_wide_wide() { int2x3 a0 = int2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void int2x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_and_wide_scalar() { int2x3 a0 = int2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void int2x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void int2x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_or_wide_wide() { int2x3 a0 = int2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void int2x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_or_wide_scalar() { int2x3 a0 = int2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void int2x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void int2x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_xor_wide_wide() { int2x3 a0 = int2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void int2x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_xor_wide_scalar() { int2x3 a0 = int2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void int2x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void int2x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_left_shift() { int2x3 a0 = int2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void int2x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_right_shift() { int2x3 a0 = int2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void int2x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x3_operator_bitwise_not() { int2x3 a0 = int2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); @@ -1222,7 +1222,7 @@ public static void int2x3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int2x3_EqualsObjectOverride() { TestUtils.IsFalse(new int2x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt2x4.gen.cs b/src/Tests/Tests/Shared/TestInt2x4.gen.cs index f9650035..8700456f 100644 --- a/src/Tests/Tests/Shared/TestInt2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_zero() { TestUtils.AreEqual(0, int2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void int2x4_zero() TestUtils.AreEqual(0, int2x4.zero.c3.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_equal_wide_wide() { int2x4 a0 = int2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void int2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_equal_wide_scalar() { int2x4 a0 = int2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void int2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -100,7 +100,7 @@ public static void int2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_not_equal_wide_wide() { int2x4 a0 = int2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void int2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_not_equal_wide_scalar() { int2x4 a0 = int2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void int2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -172,7 +172,7 @@ public static void int2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_less_wide_wide() { int2x4 a0 = int2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void int2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_less_wide_scalar() { int2x4 a0 = int2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void int2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_less_scalar_wide() { int a0 = (186400299); @@ -244,7 +244,7 @@ public static void int2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_greater_wide_wide() { int2x4 a0 = int2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void int2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_greater_wide_scalar() { int2x4 a0 = int2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void int2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -316,7 +316,7 @@ public static void int2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_less_equal_wide_wide() { int2x4 a0 = int2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void int2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_less_equal_wide_scalar() { int2x4 a0 = int2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void int2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -388,7 +388,7 @@ public static void int2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_greater_equal_wide_wide() { int2x4 a0 = int2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void int2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_greater_equal_wide_scalar() { int2x4 a0 = int2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void int2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -460,7 +460,7 @@ public static void int2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_add_wide_wide() { int2x4 a0 = int2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void int2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_add_wide_scalar() { int2x4 a0 = int2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void int2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_add_scalar_wide() { int a0 = (359966320); @@ -532,7 +532,7 @@ public static void int2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_sub_wide_wide() { int2x4 a0 = int2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void int2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_sub_wide_scalar() { int2x4 a0 = int2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void int2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -604,7 +604,7 @@ public static void int2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_mul_wide_wide() { int2x4 a0 = int2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void int2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_mul_wide_scalar() { int2x4 a0 = int2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void int2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -676,7 +676,7 @@ public static void int2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_div_wide_wide() { int2x4 a0 = int2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void int2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_div_wide_scalar() { int2x4 a0 = int2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void int2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_div_scalar_wide() { int a0 = (519165704); @@ -748,7 +748,7 @@ public static void int2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_mod_wide_wide() { int2x4 a0 = int2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void int2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_mod_wide_scalar() { int2x4 a0 = int2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void int2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -820,7 +820,7 @@ public static void int2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_plus() { int2x4 a0 = int2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void int2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_neg() { int2x4 a0 = int2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void int2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_prefix_inc() { int2x4 a0 = int2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void int2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_postfix_inc() { int2x4 a0 = int2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void int2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_prefix_dec() { int2x4 a0 = int2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void int2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_postfix_dec() { int2x4 a0 = int2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void int2x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_and_wide_wide() { int2x4 a0 = int2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void int2x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_and_wide_scalar() { int2x4 a0 = int2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void int2x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void int2x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_or_wide_wide() { int2x4 a0 = int2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void int2x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_or_wide_scalar() { int2x4 a0 = int2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void int2x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void int2x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_xor_wide_wide() { int2x4 a0 = int2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void int2x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_xor_wide_scalar() { int2x4 a0 = int2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void int2x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void int2x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_left_shift() { int2x4 a0 = int2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void int2x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_right_shift() { int2x4 a0 = int2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void int2x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2x4_operator_bitwise_not() { int2x4 a0 = int2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); @@ -1224,7 +1224,7 @@ public static void int2x4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int2x4_EqualsObjectOverride() { TestUtils.IsFalse(new int2x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt3.gen.cs b/src/Tests/Tests/Shared/TestInt3.gen.cs index 29f8ec66..92b93317 100644 --- a/src/Tests/Tests/Shared/TestInt3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_zero() { TestUtils.AreEqual(0, int3.zero.x); @@ -23,7 +23,7 @@ public static void int3_zero() TestUtils.AreEqual(0, int3.zero.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_constructor() { int3 a = new int3(1, 2, 3); @@ -32,7 +32,7 @@ public static void int3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_scalar_constructor() { int3 a = new int3(17); @@ -41,7 +41,7 @@ public static void int3_scalar_constructor() TestUtils.AreEqual(17, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_static_constructor() { int3 a = int3(1, 2, 3); @@ -50,7 +50,7 @@ public static void int3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_static_scalar_constructor() { int3 a = int3(17); @@ -59,7 +59,7 @@ public static void int3_static_scalar_constructor() TestUtils.AreEqual(17, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_equal_wide_wide() { int3 a0 = int3(2105871082, 35218899, 1550755093); @@ -83,7 +83,7 @@ public static void int3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_equal_wide_scalar() { int3 a0 = int3(437822262, 2020661134, 541786900); @@ -107,7 +107,7 @@ public static void int3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -131,7 +131,7 @@ public static void int3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_not_equal_wide_wide() { int3 a0 = int3(1977284100, 1293292704, 1547283851); @@ -155,7 +155,7 @@ public static void int3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_not_equal_wide_scalar() { int3 a0 = int3(1038269360, 1427812625, 103361237); @@ -179,7 +179,7 @@ public static void int3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -203,7 +203,7 @@ public static void int3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_less_wide_wide() { int3 a0 = int3(1486550609, 1779244308, 1602148045); @@ -227,7 +227,7 @@ public static void int3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_less_wide_scalar() { int3 a0 = int3(796797557, 670113454, 933579492); @@ -251,7 +251,7 @@ public static void int3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_less_scalar_wide() { int a0 = (186400299); @@ -275,7 +275,7 @@ public static void int3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_greater_wide_wide() { int3 a0 = int3(2087717754, 1725569452, 1298066182); @@ -299,7 +299,7 @@ public static void int3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_greater_wide_scalar() { int3 a0 = int3(1208626274, 239697208, 1979453345); @@ -323,7 +323,7 @@ public static void int3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -347,7 +347,7 @@ public static void int3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_less_equal_wide_wide() { int3 a0 = int3(154092149, 1515170149, 1083970332); @@ -371,7 +371,7 @@ public static void int3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_less_equal_wide_scalar() { int3 a0 = int3(1479531977, 1427983411, 415250630); @@ -395,7 +395,7 @@ public static void int3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -419,7 +419,7 @@ public static void int3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_greater_equal_wide_wide() { int3 a0 = int3(8538378, 2131749726, 265427108); @@ -443,7 +443,7 @@ public static void int3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_greater_equal_wide_scalar() { int3 a0 = int3(2049236663, 182691143, 634973382); @@ -467,7 +467,7 @@ public static void int3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -491,7 +491,7 @@ public static void int3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_add_wide_wide() { int3 a0 = int3(2135171378, 21433296, 1954723494); @@ -515,7 +515,7 @@ public static void int3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_add_wide_scalar() { int3 a0 = int3(665815972, 1783729250, 1591678394); @@ -539,7 +539,7 @@ public static void int3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_add_scalar_wide() { int a0 = (359966320); @@ -563,7 +563,7 @@ public static void int3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_sub_wide_wide() { int3 a0 = int3(1410318491, 1097280168, 1827039044); @@ -587,7 +587,7 @@ public static void int3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_sub_wide_scalar() { int3 a0 = int3(1508669340, 1594795463, 266707545); @@ -611,7 +611,7 @@ public static void int3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -635,7 +635,7 @@ public static void int3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_mul_wide_wide() { int3 a0 = int3(61417577, 219585476, 1362520891); @@ -659,7 +659,7 @@ public static void int3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_mul_wide_scalar() { int3 a0 = int3(871746615, 492532311, 570557670); @@ -683,7 +683,7 @@ public static void int3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -707,7 +707,7 @@ public static void int3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_div_wide_wide() { int3 a0 = int3(333171510, 858154903, 1181365836); @@ -731,7 +731,7 @@ public static void int3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_div_wide_scalar() { int3 a0 = int3(1433072926, 1073958635, 1195142312); @@ -755,7 +755,7 @@ public static void int3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_div_scalar_wide() { int a0 = (519165704); @@ -779,7 +779,7 @@ public static void int3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_mod_wide_wide() { int3 a0 = int3(258342924, 1454754891, 723352342); @@ -803,7 +803,7 @@ public static void int3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_mod_wide_scalar() { int3 a0 = int3(560988938, 629524514, 767711194); @@ -827,7 +827,7 @@ public static void int3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -851,7 +851,7 @@ public static void int3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_plus() { int3 a0 = int3(195392567, 222719748, 1002351013); @@ -871,7 +871,7 @@ public static void int3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_neg() { int3 a0 = int3(1385088677, 94114564, 1350664872); @@ -891,7 +891,7 @@ public static void int3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_prefix_inc() { int3 a0 = int3(780471723, 954741756, 272723451); @@ -911,7 +911,7 @@ public static void int3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_postfix_inc() { int3 a0 = int3(241865086, 2145821641, 1596166022); @@ -931,7 +931,7 @@ public static void int3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_prefix_dec() { int3 a0 = int3(1331961415, 1612382200, 1401591249); @@ -951,7 +951,7 @@ public static void int3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_postfix_dec() { int3 a0 = int3(1870005937, 1708534798, 704493460); @@ -971,7 +971,7 @@ public static void int3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_and_wide_wide() { int3 a0 = int3(1055241304, 859321394, 1088358961); @@ -995,7 +995,7 @@ public static void int3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_and_wide_scalar() { int3 a0 = int3(1513158868, 284695609, 734595037); @@ -1019,7 +1019,7 @@ public static void int3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1043,7 +1043,7 @@ public static void int3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_or_wide_wide() { int3 a0 = int3(1920951869, 1750772852, 1420019191); @@ -1067,7 +1067,7 @@ public static void int3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_or_wide_scalar() { int3 a0 = int3(1295304853, 1307252624, 350194630); @@ -1091,7 +1091,7 @@ public static void int3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1115,7 +1115,7 @@ public static void int3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_xor_wide_wide() { int3 a0 = int3(1843655608, 362425681, 640805534); @@ -1139,7 +1139,7 @@ public static void int3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_xor_wide_scalar() { int3 a0 = int3(169345668, 176087064, 2084362901); @@ -1163,7 +1163,7 @@ public static void int3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1187,7 +1187,7 @@ public static void int3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_left_shift() { int3 a0 = int3(1129100049, 829482269, 1571297368); @@ -1211,7 +1211,7 @@ public static void int3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_right_shift() { int3 a0 = int3(809126085, 908563670, 763568837); @@ -1235,7 +1235,7 @@ public static void int3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_operator_bitwise_not() { int3 a0 = int3(111796841, 603562399, 745091931); @@ -1255,7 +1255,7 @@ public static void int3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_shuffle_result_1() { int3 a = int3(0, 1, 2); @@ -1269,7 +1269,7 @@ public static void int3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_shuffle_result_2() { int3 a = int3(0, 1, 2); @@ -1293,7 +1293,7 @@ public static void int3_shuffle_result_2() TestUtils.AreEqual(int2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_shuffle_result_3() { int3 a = int3(0, 1, 2); @@ -1317,7 +1317,7 @@ public static void int3_shuffle_result_3() TestUtils.AreEqual(int3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_shuffle_result_4() { int3 a = int3(0, 1, 2); @@ -1341,7 +1341,7 @@ public static void int3_shuffle_result_4() TestUtils.AreEqual(int4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void int3_EqualsObjectOverride() { TestUtils.IsFalse(new int3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt3x2.gen.cs b/src/Tests/Tests/Shared/TestInt3x2.gen.cs index 11b9edb4..769f2d00 100644 --- a/src/Tests/Tests/Shared/TestInt3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_zero() { TestUtils.AreEqual(0, int3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void int3x2_zero() TestUtils.AreEqual(0, int3x2.zero.c1.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_equal_wide_wide() { int3x2 a0 = int3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void int3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_equal_wide_scalar() { int3x2 a0 = int3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void int3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -98,7 +98,7 @@ public static void int3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_not_equal_wide_wide() { int3x2 a0 = int3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void int3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_not_equal_wide_scalar() { int3x2 a0 = int3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void int3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -170,7 +170,7 @@ public static void int3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_less_wide_wide() { int3x2 a0 = int3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void int3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_less_wide_scalar() { int3x2 a0 = int3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void int3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_less_scalar_wide() { int a0 = (186400299); @@ -242,7 +242,7 @@ public static void int3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_greater_wide_wide() { int3x2 a0 = int3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void int3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_greater_wide_scalar() { int3x2 a0 = int3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void int3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -314,7 +314,7 @@ public static void int3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_less_equal_wide_wide() { int3x2 a0 = int3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void int3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_less_equal_wide_scalar() { int3x2 a0 = int3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void int3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -386,7 +386,7 @@ public static void int3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_greater_equal_wide_wide() { int3x2 a0 = int3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void int3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_greater_equal_wide_scalar() { int3x2 a0 = int3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void int3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -458,7 +458,7 @@ public static void int3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_add_wide_wide() { int3x2 a0 = int3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void int3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_add_wide_scalar() { int3x2 a0 = int3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void int3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_add_scalar_wide() { int a0 = (359966320); @@ -530,7 +530,7 @@ public static void int3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_sub_wide_wide() { int3x2 a0 = int3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void int3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_sub_wide_scalar() { int3x2 a0 = int3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void int3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -602,7 +602,7 @@ public static void int3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_mul_wide_wide() { int3x2 a0 = int3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void int3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_mul_wide_scalar() { int3x2 a0 = int3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void int3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -674,7 +674,7 @@ public static void int3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_div_wide_wide() { int3x2 a0 = int3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void int3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_div_wide_scalar() { int3x2 a0 = int3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void int3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_div_scalar_wide() { int a0 = (519165704); @@ -746,7 +746,7 @@ public static void int3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_mod_wide_wide() { int3x2 a0 = int3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void int3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_mod_wide_scalar() { int3x2 a0 = int3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void int3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -818,7 +818,7 @@ public static void int3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_plus() { int3x2 a0 = int3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void int3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_neg() { int3x2 a0 = int3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void int3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_prefix_inc() { int3x2 a0 = int3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void int3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_postfix_inc() { int3x2 a0 = int3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void int3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_prefix_dec() { int3x2 a0 = int3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void int3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_postfix_dec() { int3x2 a0 = int3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void int3x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_and_wide_wide() { int3x2 a0 = int3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void int3x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_and_wide_scalar() { int3x2 a0 = int3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void int3x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void int3x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_or_wide_wide() { int3x2 a0 = int3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void int3x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_or_wide_scalar() { int3x2 a0 = int3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void int3x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void int3x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_xor_wide_wide() { int3x2 a0 = int3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void int3x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_xor_wide_scalar() { int3x2 a0 = int3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void int3x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void int3x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_left_shift() { int3x2 a0 = int3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void int3x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_right_shift() { int3x2 a0 = int3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void int3x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x2_operator_bitwise_not() { int3x2 a0 = int3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); @@ -1222,7 +1222,7 @@ public static void int3x2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int3x2_EqualsObjectOverride() { TestUtils.IsFalse(new int3x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt3x3.gen.cs b/src/Tests/Tests/Shared/TestInt3x3.gen.cs index e5b804e0..c2a99c4f 100644 --- a/src/Tests/Tests/Shared/TestInt3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_zero() { TestUtils.AreEqual(0, int3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void int3x3_zero() TestUtils.AreEqual(0, int3x3.zero.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_identity() { TestUtils.AreEqual(1, int3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void int3x3_identity() TestUtils.AreEqual(1, int3x3.identity.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_equal_wide_wide() { int3x3 a0 = int3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367); @@ -67,7 +67,7 @@ public static void int3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_equal_wide_scalar() { int3x3 a0 = int3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998); @@ -91,7 +91,7 @@ public static void int3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -115,7 +115,7 @@ public static void int3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_not_equal_wide_wide() { int3x3 a0 = int3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678); @@ -139,7 +139,7 @@ public static void int3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_not_equal_wide_scalar() { int3x3 a0 = int3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423); @@ -163,7 +163,7 @@ public static void int3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -187,7 +187,7 @@ public static void int3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_less_wide_wide() { int3x3 a0 = int3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312); @@ -211,7 +211,7 @@ public static void int3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_less_wide_scalar() { int3x3 a0 = int3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597); @@ -235,7 +235,7 @@ public static void int3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_less_scalar_wide() { int a0 = (186400299); @@ -259,7 +259,7 @@ public static void int3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_greater_wide_wide() { int3x3 a0 = int3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133); @@ -283,7 +283,7 @@ public static void int3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_greater_wide_scalar() { int3x3 a0 = int3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855); @@ -307,7 +307,7 @@ public static void int3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -331,7 +331,7 @@ public static void int3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_less_equal_wide_wide() { int3x3 a0 = int3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541); @@ -355,7 +355,7 @@ public static void int3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_less_equal_wide_scalar() { int3x3 a0 = int3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375); @@ -379,7 +379,7 @@ public static void int3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -403,7 +403,7 @@ public static void int3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_greater_equal_wide_wide() { int3x3 a0 = int3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826); @@ -427,7 +427,7 @@ public static void int3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_greater_equal_wide_scalar() { int3x3 a0 = int3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669); @@ -451,7 +451,7 @@ public static void int3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -475,7 +475,7 @@ public static void int3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_add_wide_wide() { int3x3 a0 = int3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600); @@ -499,7 +499,7 @@ public static void int3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_add_wide_scalar() { int3x3 a0 = int3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008); @@ -523,7 +523,7 @@ public static void int3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_add_scalar_wide() { int a0 = (359966320); @@ -547,7 +547,7 @@ public static void int3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_sub_wide_wide() { int3x3 a0 = int3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315); @@ -571,7 +571,7 @@ public static void int3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_sub_wide_scalar() { int3x3 a0 = int3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113); @@ -595,7 +595,7 @@ public static void int3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -619,7 +619,7 @@ public static void int3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_mul_wide_wide() { int3x3 a0 = int3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583); @@ -643,7 +643,7 @@ public static void int3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_mul_wide_scalar() { int3x3 a0 = int3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059); @@ -667,7 +667,7 @@ public static void int3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -691,7 +691,7 @@ public static void int3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_div_wide_wide() { int3x3 a0 = int3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195); @@ -715,7 +715,7 @@ public static void int3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_div_wide_scalar() { int3x3 a0 = int3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136); @@ -739,7 +739,7 @@ public static void int3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_div_scalar_wide() { int a0 = (519165704); @@ -763,7 +763,7 @@ public static void int3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_mod_wide_wide() { int3x3 a0 = int3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101); @@ -787,7 +787,7 @@ public static void int3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_mod_wide_scalar() { int3x3 a0 = int3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144); @@ -811,7 +811,7 @@ public static void int3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -835,7 +835,7 @@ public static void int3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_plus() { int3x3 a0 = int3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671); @@ -855,7 +855,7 @@ public static void int3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_neg() { int3x3 a0 = int3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525); @@ -875,7 +875,7 @@ public static void int3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_prefix_inc() { int3x3 a0 = int3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994); @@ -895,7 +895,7 @@ public static void int3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_postfix_inc() { int3x3 a0 = int3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247); @@ -915,7 +915,7 @@ public static void int3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_prefix_dec() { int3x3 a0 = int3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745); @@ -935,7 +935,7 @@ public static void int3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_postfix_dec() { int3x3 a0 = int3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889); @@ -955,7 +955,7 @@ public static void int3x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_and_wide_wide() { int3x3 a0 = int3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656); @@ -979,7 +979,7 @@ public static void int3x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_and_wide_scalar() { int3x3 a0 = int3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263); @@ -1003,7 +1003,7 @@ public static void int3x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1027,7 +1027,7 @@ public static void int3x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_or_wide_wide() { int3x3 a0 = int3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869); @@ -1051,7 +1051,7 @@ public static void int3x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_or_wide_scalar() { int3x3 a0 = int3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307); @@ -1075,7 +1075,7 @@ public static void int3x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1099,7 +1099,7 @@ public static void int3x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_xor_wide_wide() { int3x3 a0 = int3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251); @@ -1123,7 +1123,7 @@ public static void int3x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_xor_wide_scalar() { int3x3 a0 = int3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873); @@ -1147,7 +1147,7 @@ public static void int3x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1171,7 +1171,7 @@ public static void int3x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_left_shift() { int3x3 a0 = int3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727); @@ -1195,7 +1195,7 @@ public static void int3x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_right_shift() { int3x3 a0 = int3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393); @@ -1219,7 +1219,7 @@ public static void int3x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x3_operator_bitwise_not() { int3x3 a0 = int3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628); @@ -1239,7 +1239,7 @@ public static void int3x3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int3x3_EqualsObjectOverride() { TestUtils.IsFalse(new int3x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt3x4.gen.cs b/src/Tests/Tests/Shared/TestInt3x4.gen.cs index 254a797c..449377a8 100644 --- a/src/Tests/Tests/Shared/TestInt3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_zero() { TestUtils.AreEqual(0, int3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void int3x4_zero() TestUtils.AreEqual(0, int3x4.zero.c3.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_equal_wide_wide() { int3x4 a0 = int3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void int3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_equal_wide_scalar() { int3x4 a0 = int3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void int3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -104,7 +104,7 @@ public static void int3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_not_equal_wide_wide() { int3x4 a0 = int3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void int3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_not_equal_wide_scalar() { int3x4 a0 = int3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void int3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -176,7 +176,7 @@ public static void int3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_less_wide_wide() { int3x4 a0 = int3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void int3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_less_wide_scalar() { int3x4 a0 = int3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void int3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_less_scalar_wide() { int a0 = (186400299); @@ -248,7 +248,7 @@ public static void int3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_greater_wide_wide() { int3x4 a0 = int3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void int3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_greater_wide_scalar() { int3x4 a0 = int3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void int3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -320,7 +320,7 @@ public static void int3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_less_equal_wide_wide() { int3x4 a0 = int3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void int3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_less_equal_wide_scalar() { int3x4 a0 = int3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void int3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -392,7 +392,7 @@ public static void int3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_greater_equal_wide_wide() { int3x4 a0 = int3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void int3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_greater_equal_wide_scalar() { int3x4 a0 = int3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void int3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -464,7 +464,7 @@ public static void int3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_add_wide_wide() { int3x4 a0 = int3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void int3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_add_wide_scalar() { int3x4 a0 = int3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void int3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_add_scalar_wide() { int a0 = (359966320); @@ -536,7 +536,7 @@ public static void int3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_sub_wide_wide() { int3x4 a0 = int3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void int3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_sub_wide_scalar() { int3x4 a0 = int3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void int3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -608,7 +608,7 @@ public static void int3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_mul_wide_wide() { int3x4 a0 = int3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void int3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_mul_wide_scalar() { int3x4 a0 = int3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void int3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -680,7 +680,7 @@ public static void int3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_div_wide_wide() { int3x4 a0 = int3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void int3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_div_wide_scalar() { int3x4 a0 = int3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void int3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_div_scalar_wide() { int a0 = (519165704); @@ -752,7 +752,7 @@ public static void int3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_mod_wide_wide() { int3x4 a0 = int3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void int3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_mod_wide_scalar() { int3x4 a0 = int3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void int3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -824,7 +824,7 @@ public static void int3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_plus() { int3x4 a0 = int3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void int3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_neg() { int3x4 a0 = int3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void int3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_prefix_inc() { int3x4 a0 = int3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void int3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_postfix_inc() { int3x4 a0 = int3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void int3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_prefix_dec() { int3x4 a0 = int3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void int3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_postfix_dec() { int3x4 a0 = int3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void int3x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_and_wide_wide() { int3x4 a0 = int3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void int3x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_and_wide_scalar() { int3x4 a0 = int3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void int3x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void int3x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_or_wide_wide() { int3x4 a0 = int3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void int3x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_or_wide_scalar() { int3x4 a0 = int3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void int3x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void int3x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_xor_wide_wide() { int3x4 a0 = int3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void int3x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_xor_wide_scalar() { int3x4 a0 = int3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void int3x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void int3x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_left_shift() { int3x4 a0 = int3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void int3x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_right_shift() { int3x4 a0 = int3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void int3x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3x4_operator_bitwise_not() { int3x4 a0 = int3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); @@ -1228,7 +1228,7 @@ public static void int3x4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int3x4_EqualsObjectOverride() { TestUtils.IsFalse(new int3x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt4.gen.cs b/src/Tests/Tests/Shared/TestInt4.gen.cs index 065bb609..5aaff365 100644 --- a/src/Tests/Tests/Shared/TestInt4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_zero() { TestUtils.AreEqual(0, int4.zero.x); @@ -24,7 +24,7 @@ public static void int4_zero() TestUtils.AreEqual(0, int4.zero.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_constructor() { int4 a = new int4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void int4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_scalar_constructor() { int4 a = new int4(17); @@ -44,7 +44,7 @@ public static void int4_scalar_constructor() TestUtils.AreEqual(17, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_static_constructor() { int4 a = int4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void int4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_static_scalar_constructor() { int4 a = int4(17); @@ -64,7 +64,7 @@ public static void int4_static_scalar_constructor() TestUtils.AreEqual(17, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_equal_wide_wide() { int4 a0 = int4(2105871082, 35218899, 1550755093, 764676020); @@ -88,7 +88,7 @@ public static void int4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_equal_wide_scalar() { int4 a0 = int4(437822262, 2020661134, 541786900, 853113810); @@ -112,7 +112,7 @@ public static void int4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -136,7 +136,7 @@ public static void int4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_not_equal_wide_wide() { int4 a0 = int4(1977284100, 1293292704, 1547283851, 422428953); @@ -160,7 +160,7 @@ public static void int4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_not_equal_wide_scalar() { int4 a0 = int4(1038269360, 1427812625, 103361237, 1347017023); @@ -184,7 +184,7 @@ public static void int4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -208,7 +208,7 @@ public static void int4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_less_wide_wide() { int4 a0 = int4(1486550609, 1779244308, 1602148045, 1614085440); @@ -232,7 +232,7 @@ public static void int4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_less_wide_scalar() { int4 a0 = int4(796797557, 670113454, 933579492, 278884514); @@ -256,7 +256,7 @@ public static void int4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_less_scalar_wide() { int a0 = (186400299); @@ -280,7 +280,7 @@ public static void int4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_greater_wide_wide() { int4 a0 = int4(2087717754, 1725569452, 1298066182, 1693943616); @@ -304,7 +304,7 @@ public static void int4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_greater_wide_scalar() { int4 a0 = int4(1208626274, 239697208, 1979453345, 1253474001); @@ -328,7 +328,7 @@ public static void int4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -352,7 +352,7 @@ public static void int4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_less_equal_wide_wide() { int4 a0 = int4(154092149, 1515170149, 1083970332, 785807178); @@ -376,7 +376,7 @@ public static void int4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_less_equal_wide_scalar() { int4 a0 = int4(1479531977, 1427983411, 415250630, 1245345407); @@ -400,7 +400,7 @@ public static void int4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -424,7 +424,7 @@ public static void int4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_greater_equal_wide_wide() { int4 a0 = int4(8538378, 2131749726, 265427108, 523609761); @@ -448,7 +448,7 @@ public static void int4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_greater_equal_wide_scalar() { int4 a0 = int4(2049236663, 182691143, 634973382, 1197012109); @@ -472,7 +472,7 @@ public static void int4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -496,7 +496,7 @@ public static void int4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_add_wide_wide() { int4 a0 = int4(2135171378, 21433296, 1954723494, 683604307); @@ -520,7 +520,7 @@ public static void int4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_add_wide_scalar() { int4 a0 = int4(665815972, 1783729250, 1591678394, 1284528538); @@ -544,7 +544,7 @@ public static void int4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_add_scalar_wide() { int a0 = (359966320); @@ -568,7 +568,7 @@ public static void int4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_sub_wide_wide() { int4 a0 = int4(1410318491, 1097280168, 1827039044, 28881338); @@ -592,7 +592,7 @@ public static void int4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_sub_wide_scalar() { int4 a0 = int4(1508669340, 1594795463, 266707545, 643102647); @@ -616,7 +616,7 @@ public static void int4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -640,7 +640,7 @@ public static void int4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_mul_wide_wide() { int4 a0 = int4(61417577, 219585476, 1362520891, 1511084277); @@ -664,7 +664,7 @@ public static void int4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_mul_wide_scalar() { int4 a0 = int4(871746615, 492532311, 570557670, 2142306629); @@ -688,7 +688,7 @@ public static void int4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -712,7 +712,7 @@ public static void int4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_div_wide_wide() { int4 a0 = int4(333171510, 858154903, 1181365836, 671357749); @@ -736,7 +736,7 @@ public static void int4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_div_wide_scalar() { int4 a0 = int4(1433072926, 1073958635, 1195142312, 536596719); @@ -760,7 +760,7 @@ public static void int4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_div_scalar_wide() { int a0 = (519165704); @@ -784,7 +784,7 @@ public static void int4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_mod_wide_wide() { int4 a0 = int4(258342924, 1454754891, 723352342, 1981431473); @@ -808,7 +808,7 @@ public static void int4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_mod_wide_scalar() { int4 a0 = int4(560988938, 629524514, 767711194, 434281967); @@ -832,7 +832,7 @@ public static void int4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -856,7 +856,7 @@ public static void int4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_plus() { int4 a0 = int4(195392567, 222719748, 1002351013, 1570765263); @@ -876,7 +876,7 @@ public static void int4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_neg() { int4 a0 = int4(1385088677, 94114564, 1350664872, 1458616659); @@ -896,7 +896,7 @@ public static void int4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_prefix_inc() { int4 a0 = int4(780471723, 954741756, 272723451, 2142862245); @@ -916,7 +916,7 @@ public static void int4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_postfix_inc() { int4 a0 = int4(241865086, 2145821641, 1596166022, 803592338); @@ -936,7 +936,7 @@ public static void int4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_prefix_dec() { int4 a0 = int4(1331961415, 1612382200, 1401591249, 2042075388); @@ -956,7 +956,7 @@ public static void int4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_postfix_dec() { int4 a0 = int4(1870005937, 1708534798, 704493460, 462940703); @@ -976,7 +976,7 @@ public static void int4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_and_wide_wide() { int4 a0 = int4(1055241304, 859321394, 1088358961, 2090949513); @@ -1000,7 +1000,7 @@ public static void int4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_and_wide_scalar() { int4 a0 = int4(1513158868, 284695609, 734595037, 1566510707); @@ -1024,7 +1024,7 @@ public static void int4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1048,7 +1048,7 @@ public static void int4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_or_wide_wide() { int4 a0 = int4(1920951869, 1750772852, 1420019191, 732977093); @@ -1072,7 +1072,7 @@ public static void int4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_or_wide_scalar() { int4 a0 = int4(1295304853, 1307252624, 350194630, 1128063578); @@ -1096,7 +1096,7 @@ public static void int4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1120,7 +1120,7 @@ public static void int4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_xor_wide_wide() { int4 a0 = int4(1843655608, 362425681, 640805534, 1342040268); @@ -1144,7 +1144,7 @@ public static void int4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_xor_wide_scalar() { int4 a0 = int4(169345668, 176087064, 2084362901, 1663924004); @@ -1168,7 +1168,7 @@ public static void int4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1192,7 +1192,7 @@ public static void int4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_left_shift() { int4 a0 = int4(1129100049, 829482269, 1571297368, 443753193); @@ -1216,7 +1216,7 @@ public static void int4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_right_shift() { int4 a0 = int4(809126085, 908563670, 763568837, 1986717290); @@ -1240,7 +1240,7 @@ public static void int4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_operator_bitwise_not() { int4 a0 = int4(111796841, 603562399, 745091931, 853183268); @@ -1260,7 +1260,7 @@ public static void int4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_shuffle_result_1() { int4 a = int4(0, 1, 2, 3); @@ -1276,7 +1276,7 @@ public static void int4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_shuffle_result_2() { int4 a = int4(0, 1, 2, 3); @@ -1300,7 +1300,7 @@ public static void int4_shuffle_result_2() TestUtils.AreEqual(int2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_shuffle_result_3() { int4 a = int4(0, 1, 2, 3); @@ -1324,7 +1324,7 @@ public static void int4_shuffle_result_3() TestUtils.AreEqual(int3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_shuffle_result_4() { int4 a = int4(0, 1, 2, 3); @@ -1348,7 +1348,7 @@ public static void int4_shuffle_result_4() TestUtils.AreEqual(int4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void int4_EqualsObjectOverride() { TestUtils.IsFalse(new int4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt4x2.gen.cs b/src/Tests/Tests/Shared/TestInt4x2.gen.cs index 564c7aa7..c4528cd7 100644 --- a/src/Tests/Tests/Shared/TestInt4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_zero() { TestUtils.AreEqual(0, int4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void int4x2_zero() TestUtils.AreEqual(0, int4x2.zero.c1.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_equal_wide_wide() { int4x2 a0 = int4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void int4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_equal_wide_scalar() { int4x2 a0 = int4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void int4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -100,7 +100,7 @@ public static void int4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_not_equal_wide_wide() { int4x2 a0 = int4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void int4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_not_equal_wide_scalar() { int4x2 a0 = int4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void int4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -172,7 +172,7 @@ public static void int4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_less_wide_wide() { int4x2 a0 = int4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void int4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_less_wide_scalar() { int4x2 a0 = int4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void int4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_less_scalar_wide() { int a0 = (186400299); @@ -244,7 +244,7 @@ public static void int4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_greater_wide_wide() { int4x2 a0 = int4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void int4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_greater_wide_scalar() { int4x2 a0 = int4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void int4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -316,7 +316,7 @@ public static void int4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_less_equal_wide_wide() { int4x2 a0 = int4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void int4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_less_equal_wide_scalar() { int4x2 a0 = int4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void int4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -388,7 +388,7 @@ public static void int4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_greater_equal_wide_wide() { int4x2 a0 = int4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void int4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_greater_equal_wide_scalar() { int4x2 a0 = int4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void int4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -460,7 +460,7 @@ public static void int4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_add_wide_wide() { int4x2 a0 = int4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void int4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_add_wide_scalar() { int4x2 a0 = int4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void int4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_add_scalar_wide() { int a0 = (359966320); @@ -532,7 +532,7 @@ public static void int4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_sub_wide_wide() { int4x2 a0 = int4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void int4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_sub_wide_scalar() { int4x2 a0 = int4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void int4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -604,7 +604,7 @@ public static void int4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_mul_wide_wide() { int4x2 a0 = int4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void int4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_mul_wide_scalar() { int4x2 a0 = int4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void int4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -676,7 +676,7 @@ public static void int4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_div_wide_wide() { int4x2 a0 = int4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void int4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_div_wide_scalar() { int4x2 a0 = int4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void int4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_div_scalar_wide() { int a0 = (519165704); @@ -748,7 +748,7 @@ public static void int4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_mod_wide_wide() { int4x2 a0 = int4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void int4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_mod_wide_scalar() { int4x2 a0 = int4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void int4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -820,7 +820,7 @@ public static void int4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_plus() { int4x2 a0 = int4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void int4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_neg() { int4x2 a0 = int4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void int4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_prefix_inc() { int4x2 a0 = int4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void int4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_postfix_inc() { int4x2 a0 = int4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void int4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_prefix_dec() { int4x2 a0 = int4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void int4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_postfix_dec() { int4x2 a0 = int4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void int4x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_and_wide_wide() { int4x2 a0 = int4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void int4x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_and_wide_scalar() { int4x2 a0 = int4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void int4x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void int4x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_or_wide_wide() { int4x2 a0 = int4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void int4x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_or_wide_scalar() { int4x2 a0 = int4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void int4x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void int4x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_xor_wide_wide() { int4x2 a0 = int4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void int4x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_xor_wide_scalar() { int4x2 a0 = int4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void int4x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void int4x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_left_shift() { int4x2 a0 = int4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void int4x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_right_shift() { int4x2 a0 = int4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void int4x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x2_operator_bitwise_not() { int4x2 a0 = int4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); @@ -1224,7 +1224,7 @@ public static void int4x2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int4x2_EqualsObjectOverride() { TestUtils.IsFalse(new int4x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt4x3.gen.cs b/src/Tests/Tests/Shared/TestInt4x3.gen.cs index 6fdd2f07..fec49565 100644 --- a/src/Tests/Tests/Shared/TestInt4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_zero() { TestUtils.AreEqual(0, int4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void int4x3_zero() TestUtils.AreEqual(0, int4x3.zero.c2.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_equal_wide_wide() { int4x3 a0 = int4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void int4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_equal_wide_scalar() { int4x3 a0 = int4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void int4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -104,7 +104,7 @@ public static void int4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_not_equal_wide_wide() { int4x3 a0 = int4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void int4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_not_equal_wide_scalar() { int4x3 a0 = int4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void int4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -176,7 +176,7 @@ public static void int4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_less_wide_wide() { int4x3 a0 = int4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void int4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_less_wide_scalar() { int4x3 a0 = int4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void int4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_less_scalar_wide() { int a0 = (186400299); @@ -248,7 +248,7 @@ public static void int4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_greater_wide_wide() { int4x3 a0 = int4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void int4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_greater_wide_scalar() { int4x3 a0 = int4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void int4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -320,7 +320,7 @@ public static void int4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_less_equal_wide_wide() { int4x3 a0 = int4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void int4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_less_equal_wide_scalar() { int4x3 a0 = int4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void int4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -392,7 +392,7 @@ public static void int4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_greater_equal_wide_wide() { int4x3 a0 = int4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void int4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_greater_equal_wide_scalar() { int4x3 a0 = int4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void int4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -464,7 +464,7 @@ public static void int4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_add_wide_wide() { int4x3 a0 = int4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void int4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_add_wide_scalar() { int4x3 a0 = int4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void int4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_add_scalar_wide() { int a0 = (359966320); @@ -536,7 +536,7 @@ public static void int4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_sub_wide_wide() { int4x3 a0 = int4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void int4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_sub_wide_scalar() { int4x3 a0 = int4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void int4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -608,7 +608,7 @@ public static void int4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_mul_wide_wide() { int4x3 a0 = int4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void int4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_mul_wide_scalar() { int4x3 a0 = int4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void int4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -680,7 +680,7 @@ public static void int4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_div_wide_wide() { int4x3 a0 = int4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void int4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_div_wide_scalar() { int4x3 a0 = int4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void int4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_div_scalar_wide() { int a0 = (519165704); @@ -752,7 +752,7 @@ public static void int4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_mod_wide_wide() { int4x3 a0 = int4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void int4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_mod_wide_scalar() { int4x3 a0 = int4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void int4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -824,7 +824,7 @@ public static void int4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_plus() { int4x3 a0 = int4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void int4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_neg() { int4x3 a0 = int4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void int4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_prefix_inc() { int4x3 a0 = int4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void int4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_postfix_inc() { int4x3 a0 = int4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void int4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_prefix_dec() { int4x3 a0 = int4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void int4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_postfix_dec() { int4x3 a0 = int4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void int4x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_and_wide_wide() { int4x3 a0 = int4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void int4x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_and_wide_scalar() { int4x3 a0 = int4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void int4x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void int4x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_or_wide_wide() { int4x3 a0 = int4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void int4x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_or_wide_scalar() { int4x3 a0 = int4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void int4x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void int4x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_xor_wide_wide() { int4x3 a0 = int4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void int4x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_xor_wide_scalar() { int4x3 a0 = int4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void int4x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void int4x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_left_shift() { int4x3 a0 = int4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void int4x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_right_shift() { int4x3 a0 = int4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void int4x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x3_operator_bitwise_not() { int4x3 a0 = int4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); @@ -1228,7 +1228,7 @@ public static void int4x3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int4x3_EqualsObjectOverride() { TestUtils.IsFalse(new int4x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestInt4x4.gen.cs b/src/Tests/Tests/Shared/TestInt4x4.gen.cs index 87f3887b..81786fb7 100644 --- a/src/Tests/Tests/Shared/TestInt4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_zero() { TestUtils.AreEqual(0, int4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void int4x4_zero() TestUtils.AreEqual(0, int4x4.zero.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_identity() { TestUtils.AreEqual(1, int4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void int4x4_identity() TestUtils.AreEqual(1, int4x4.identity.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_equal_wide_wide() { int4x4 a0 = int4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805); @@ -81,7 +81,7 @@ public static void int4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_equal_wide_scalar() { int4x4 a0 = int4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611); @@ -105,7 +105,7 @@ public static void int4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -129,7 +129,7 @@ public static void int4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_not_equal_wide_wide() { int4x4 a0 = int4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126); @@ -153,7 +153,7 @@ public static void int4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_not_equal_wide_scalar() { int4x4 a0 = int4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260); @@ -177,7 +177,7 @@ public static void int4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -201,7 +201,7 @@ public static void int4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_less_wide_wide() { int4x4 a0 = int4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012); @@ -225,7 +225,7 @@ public static void int4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_less_wide_scalar() { int4x4 a0 = int4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157); @@ -249,7 +249,7 @@ public static void int4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_less_scalar_wide() { int a0 = (186400299); @@ -273,7 +273,7 @@ public static void int4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_greater_wide_wide() { int4x4 a0 = int4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063); @@ -297,7 +297,7 @@ public static void int4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_greater_wide_scalar() { int4x4 a0 = int4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537); @@ -321,7 +321,7 @@ public static void int4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -345,7 +345,7 @@ public static void int4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_less_equal_wide_wide() { int4x4 a0 = int4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458); @@ -369,7 +369,7 @@ public static void int4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_less_equal_wide_scalar() { int4x4 a0 = int4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699); @@ -393,7 +393,7 @@ public static void int4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -417,7 +417,7 @@ public static void int4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_greater_equal_wide_wide() { int4x4 a0 = int4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690); @@ -441,7 +441,7 @@ public static void int4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_greater_equal_wide_scalar() { int4x4 a0 = int4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144); @@ -465,7 +465,7 @@ public static void int4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -489,7 +489,7 @@ public static void int4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_add_wide_wide() { int4x4 a0 = int4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699); @@ -513,7 +513,7 @@ public static void int4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_add_wide_scalar() { int4x4 a0 = int4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741); @@ -537,7 +537,7 @@ public static void int4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_add_scalar_wide() { int a0 = (359966320); @@ -561,7 +561,7 @@ public static void int4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_sub_wide_wide() { int4x4 a0 = int4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464); @@ -585,7 +585,7 @@ public static void int4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_sub_wide_scalar() { int4x4 a0 = int4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902); @@ -609,7 +609,7 @@ public static void int4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -633,7 +633,7 @@ public static void int4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_mul_wide_wide() { int4x4 a0 = int4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174); @@ -657,7 +657,7 @@ public static void int4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_mul_wide_scalar() { int4x4 a0 = int4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135); @@ -681,7 +681,7 @@ public static void int4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -705,7 +705,7 @@ public static void int4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_div_wide_wide() { int4x4 a0 = int4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781); @@ -729,7 +729,7 @@ public static void int4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_div_wide_scalar() { int4x4 a0 = int4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263); @@ -753,7 +753,7 @@ public static void int4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_div_scalar_wide() { int a0 = (519165704); @@ -777,7 +777,7 @@ public static void int4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_mod_wide_wide() { int4x4 a0 = int4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943); @@ -801,7 +801,7 @@ public static void int4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_mod_wide_scalar() { int4x4 a0 = int4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114); @@ -825,7 +825,7 @@ public static void int4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -849,7 +849,7 @@ public static void int4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_plus() { int4x4 a0 = int4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903); @@ -869,7 +869,7 @@ public static void int4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_neg() { int4x4 a0 = int4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416); @@ -889,7 +889,7 @@ public static void int4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_prefix_inc() { int4x4 a0 = int4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230); @@ -909,7 +909,7 @@ public static void int4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_postfix_inc() { int4x4 a0 = int4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180); @@ -929,7 +929,7 @@ public static void int4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_prefix_dec() { int4x4 a0 = int4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619); @@ -949,7 +949,7 @@ public static void int4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_postfix_dec() { int4x4 a0 = int4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301); @@ -969,7 +969,7 @@ public static void int4x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_and_wide_wide() { int4x4 a0 = int4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376); @@ -993,7 +993,7 @@ public static void int4x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_and_wide_scalar() { int4x4 a0 = int4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952); @@ -1017,7 +1017,7 @@ public static void int4x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1041,7 +1041,7 @@ public static void int4x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_or_wide_wide() { int4x4 a0 = int4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729); @@ -1065,7 +1065,7 @@ public static void int4x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_or_wide_scalar() { int4x4 a0 = int4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773); @@ -1089,7 +1089,7 @@ public static void int4x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1113,7 +1113,7 @@ public static void int4x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_xor_wide_wide() { int4x4 a0 = int4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576); @@ -1137,7 +1137,7 @@ public static void int4x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_xor_wide_scalar() { int4x4 a0 = int4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598); @@ -1161,7 +1161,7 @@ public static void int4x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1185,7 +1185,7 @@ public static void int4x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_left_shift() { int4x4 a0 = int4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915); @@ -1209,7 +1209,7 @@ public static void int4x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_right_shift() { int4x4 a0 = int4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287); @@ -1233,7 +1233,7 @@ public static void int4x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4x4_operator_bitwise_not() { int4x4 a0 = int4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736); @@ -1253,7 +1253,7 @@ public static void int4x4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void int4x4_EqualsObjectOverride() { TestUtils.IsFalse(new int4x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs index d22d82a7..4ba1c895 100644 --- a/src/Tests/Tests/Shared/TestMath.cs +++ b/src/Tests/Tests/Shared/TestMath.cs @@ -8,7 +8,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestMath { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_uint() { TestUtils.AreEqual(0, asint(0u)); @@ -19,7 +19,7 @@ public static void asint_uint() TestUtils.AreEqual(-1, asint(0xFFFFFFFFu)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_uint2() { TestUtils.AreEqual(int2(0, 0x12345678), asint(uint2(0u, 0x12345678u))); @@ -27,21 +27,21 @@ public static void asint_uint2() TestUtils.AreEqual(int2(-2023406815, -1), asint(uint2(0x87654321u, 0xFFFFFFFFu))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_uint3() { TestUtils.AreEqual(int3(0, 0x12345678, 0x7FFFFFFF), asint(uint3(0u, 0x12345678u, 0x7FFFFFFFu))); TestUtils.AreEqual(int3(-2147483648, -2023406815, -1), asint(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_uint4() { TestUtils.AreEqual(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648), asint(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u))); TestUtils.AreEqual(int4(-2023406815, -1, 0, 0), asint(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_float() { TestUtils.AreEqual(0, asint(0.0f)); @@ -56,14 +56,14 @@ public static void asint_float() TestUtils.AreEqual(unchecked((int)0xFF800000), asint(float.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float_signed_zero() { TestUtils.AreEqual(unchecked((int)0x80000000), asint(TestUtils.SignedFloatZero())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_float2() { TestUtils.AreEqual(int2(0, 0x3F800000), asint(float2(0.0f, 1.0f))); @@ -75,14 +75,14 @@ public static void asint_float2() TestUtils.AreEqual(int2(0, 0), asint(float2(0.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float2_signed_zero() { TestUtils.AreEqual(int2(unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_float3() { TestUtils.AreEqual(int3(0, 0x3F800000, 0x449A51EC), asint(float3(0.0f, 1.0f, 1234.56f))); @@ -91,14 +91,14 @@ public static void asint_float3() TestUtils.AreEqual(int3(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000), 0), asint(float3(-1234.56f, float.NegativeInfinity, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float3_signed_zero() { TestUtils.AreEqual(int3(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asint_float4() { TestUtils.AreEqual(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000), asint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity))); @@ -106,14 +106,14 @@ public static void asint_float4() TestUtils.AreEqual(int4(unchecked((int)0x7FC00000), unchecked((int)0xBF800000), unchecked((int)0xC49A51EC), unchecked((int)0xFF800000)), asint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float4_signed_zero() { TestUtils.AreEqual(int4(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_int() { TestUtils.AreEqual(0u, asuint(0)); @@ -124,7 +124,7 @@ public static void asuint_int() TestUtils.AreEqual(0xFFFFFFFFu, asuint(-1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_int2() { TestUtils.AreEqual(uint2(0u, 0x12345678u), asuint(int2(0, 0x12345678))); @@ -132,21 +132,21 @@ public static void asuint_int2() TestUtils.AreEqual(uint2(0x87654321u, 0xFFFFFFFFu), asuint(int2(-2023406815, -1))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_int3() { TestUtils.AreEqual(uint3(0u, 0x12345678u, 0x7FFFFFFFu), asuint(int3(0, 0x12345678, 0x7FFFFFFF))); TestUtils.AreEqual(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu), asuint(int3(-2147483648, -2023406815, -1))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_int4() { TestUtils.AreEqual(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u), asuint(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648))); TestUtils.AreEqual(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u), asuint(int4(-2023406815, -1, 0, 0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_float() { TestUtils.AreEqual(0u, asuint(0.0f)); @@ -161,14 +161,14 @@ public static void asuint_float() TestUtils.AreEqual(0xFF800000u, asuint(float.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float_signed_zero() { TestUtils.AreEqual(0x80000000u, asuint(TestUtils.SignedFloatZero())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_float2() { TestUtils.AreEqual(uint2(0u, 0x3F800000u), asuint(float2(0.0f, 1.0f))); @@ -179,14 +179,14 @@ public static void asuint_float2() TestUtils.AreEqual(uint2(0xC49A51ECu, 0xFF800000u), asuint(float2(-1234.56f, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float2_signed_zero() { TestUtils.AreEqual(uint2(0x80000000u, 0x80000000u), asuint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_float3() { TestUtils.AreEqual(uint3(0u, 0x3F800000u, 0x449A51ECu), asuint(float3(0.0f, 1.0f, 1234.56f))); @@ -195,14 +195,14 @@ public static void asuint_float3() TestUtils.AreEqual(uint3(0xC49A51ECu, 0xff800000u, 0u), asuint(float3(-1234.56f, float.NegativeInfinity, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float3_signed_zero() { TestUtils.AreEqual(uint3(0x80000000u, 0x80000000u, 0x80000000u), asuint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asuint_float4() { TestUtils.AreEqual(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u), asuint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity))); @@ -210,14 +210,14 @@ public static void asuint_float4() TestUtils.AreEqual(uint4(0x7FC00000u, 0xBF800000u, 0xC49A51ECu, 0xFF800000u), asuint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float4_singed_zero() { TestUtils.AreEqual(uint4(0x80000000u, 0x80000000u, 0x80000000u, 0x80000000u), asuint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void aslong_ulong() { TestUtils.AreEqual(0L, aslong(0ul)); @@ -228,7 +228,7 @@ public static void aslong_ulong() TestUtils.AreEqual(-1L, aslong(0xFFFFFFFFFFFFFFFFul)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void aslong_double() { TestUtils.AreEqual(0L, aslong(0.0)); @@ -242,14 +242,14 @@ public static void aslong_double() TestUtils.AreEqual(unchecked((long)0xFFF0000000000000UL), aslong(double.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void aslong_double_signed_zero() { TestUtils.AreEqual(unchecked((long)0x8000000000000000UL), aslong(TestUtils.SignedDoubleZero())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asulong_long() { TestUtils.AreEqual(0ul, asulong(0L)); @@ -260,7 +260,7 @@ public static void asulong_long() TestUtils.AreEqual(0xFFFFFFFFFFFFFFFFul, asulong(-1L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asulong_double() { TestUtils.AreEqual(0UL, asulong(0.0)); @@ -274,14 +274,14 @@ public static void asulong_double() TestUtils.AreEqual(0xFFF0000000000000UL, asulong(double.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asulong_double_signed_zero() { TestUtils.AreEqual(0x8000000000000000UL, asulong(TestUtils.SignedDoubleZero())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_int() { TestUtils.AreEqual(0.0f, asfloat(0)); @@ -297,7 +297,7 @@ public static void asfloat_int() TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(unchecked((int)0x7FC00000)))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_int2() { TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(int2(0, 0x3F800000))); @@ -309,7 +309,7 @@ public static void asfloat_int2() TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int2(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_int3() { TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(int3(0, 0x3F800000, 0x449A51EC))); @@ -320,7 +320,7 @@ public static void asfloat_int3() TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int3(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_int4() { TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000))); @@ -330,7 +330,7 @@ public static void asfloat_int4() TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int4(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_uint() { TestUtils.AreEqual(0.0f, asfloat(0u)); @@ -346,7 +346,7 @@ public static void asfloat_uint() TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(0x7FC00000u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_uint2() { TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(uint2(0u, 0x3F800000u))); @@ -358,7 +358,7 @@ public static void asfloat_uint2() TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint2(0x7FC00000u, 0x7FC00000u)))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_uint3() { TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(uint3(0u, 0x3F800000u, 0x449A51ECu))); @@ -369,7 +369,7 @@ public static void asfloat_uint3() TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint3(0x7FC00000u, 0x7FC00000u, 0x7FC00000u)))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asfloat_uint4() { TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u))); @@ -379,7 +379,7 @@ public static void asfloat_uint4() TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint4(0x7FC00000u, 0x7FC00000u, 0x7FC00000u, 0x7FC00000u)))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asdouble_long() { TestUtils.AreEqual(0.0, asdouble(0L)); @@ -394,7 +394,7 @@ public static void asdouble_long() TestUtils.AreEqual(double.NegativeInfinity, asdouble(unchecked((long)0xFFF0000000000000UL))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void asdouble_ulong() { TestUtils.AreEqual(0.0, asdouble(0UL)); @@ -409,7 +409,7 @@ public static void asdouble_ulong() TestUtils.AreEqual(double.NegativeInfinity, asdouble(0xFFF0000000000000UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void faceforward_float2() { TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(3.0f, -4.0f))); @@ -417,7 +417,7 @@ public static void faceforward_float2() TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(0.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void faceforward_float3() { TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(3.0f, -4.0f, 5.0f))); @@ -425,7 +425,7 @@ public static void faceforward_float3() TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(0.0f, 0.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void faceforward_float4() { TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(3.0f, -4.0f, 5.0f, -6.0f))); @@ -433,7 +433,7 @@ public static void faceforward_float4() TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(0.0f, 0.0f, 0.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void faceforward_double2() { TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(3.0, -4.0))); @@ -441,7 +441,7 @@ public static void faceforward_double2() TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(0.0, 0.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void faceforward_double3() { TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(3.0, -4.0, 5.0))); @@ -449,7 +449,7 @@ public static void faceforward_double3() TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(0.0, 0.0, 0.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void faceforward_double4() { TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(3.0, -4.0, 5.0, -6.0))); @@ -457,7 +457,7 @@ public static void faceforward_double4() TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(0.0, 0.0, 0.0, 0.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_float() { float f, i; @@ -474,7 +474,7 @@ public static void modf_float() TestUtils.AreEqual(0.0f, f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_float2() { float2 f, i; @@ -487,7 +487,7 @@ public static void modf_float2() TestUtils.AreEqual(float2(0.0f, 0.5f), f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_float3() { float3 f, i; @@ -496,7 +496,7 @@ public static void modf_float3() TestUtils.AreEqual(float3(0.75f, -0.25f, 0.0f), f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_float4() { float4 f, i; @@ -505,7 +505,7 @@ public static void modf_float4() TestUtils.AreEqual(float4(0.75f, -0.25f, 0.0f, 0.5f), f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_double() { double f, i; @@ -522,7 +522,7 @@ public static void modf_double() TestUtils.AreEqual(0.0, f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_double2() { double2 f, i; @@ -535,7 +535,7 @@ public static void modf_double2() TestUtils.AreEqual(double2(0.0, 0.5), f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_double3() { double3 f, i; @@ -544,7 +544,7 @@ public static void modf_double3() TestUtils.AreEqual(double3(0.75, -0.25, 0.0), f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void modf_double4() { double4 f, i; @@ -553,21 +553,21 @@ public static void modf_double4() TestUtils.AreEqual(double4(0.75, -0.25, 0.0, 0.5f), f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_float2() { TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalize(float2(3.1f, -5.3f)), 0.0001f); TestUtils.AreEqual(true, all(isnan(normalize(float2(0.0f, 0.0f))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_float3() { TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f); TestUtils.AreEqual(true, all(isnan(normalize(float3(0.0f, 0.0f, 0.0f))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_float4() { TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -575,28 +575,28 @@ public static void normalize_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_double2() { TestUtils.AreEqual(double2(0.504883, -0.863188), normalize(double2(3.1, -5.3)), 0.0001); TestUtils.AreEqual(true, all(isnan(normalize(double2(0.0, 0.0))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_double3() { TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001); TestUtils.AreEqual(true, all(isnan(normalize(double3(0.0, 0.0, 0.0))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_double4() { TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001); TestUtils.AreEqual(true, all(isnan(normalize(double4(0.0, 0.0, 0.0, 0.0f))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalize_quaternion() { TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -604,7 +604,7 @@ public static void normalize_quaternion() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_float2() { TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalizesafe(float2(3.1f, -5.3f)), 0.0001f); @@ -614,7 +614,7 @@ public static void normalizesafe_float2() TestUtils.AreEqual(float2(1.0f, 2.0f), normalizesafe(float2(7.66e-20f, 7.66e-20f), float2(1.0f, 2.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_float3() { TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f); @@ -624,7 +624,7 @@ public static void normalizesafe_float3() TestUtils.AreEqual(float3(1.0f, 2.0f, 3.0f), normalizesafe(float3(6.25e-20f, 6.25e-20f, 6.25e-20f), float3(1.0f, 2.0f, 3.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_float4() { TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -635,7 +635,7 @@ public static void normalizesafe_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_double2() { TestUtils.AreEqual(double2(0.504883, -0.863188), normalizesafe(double2(3.1, -5.3)), 0.0001); @@ -645,7 +645,7 @@ public static void normalizesafe_double2() TestUtils.AreEqual(double2(1.0, 2.0), normalizesafe(double2(1.05e-154, 1.05e-154), double2(1.0, 2.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_double3() { TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001); @@ -655,7 +655,7 @@ public static void normalizesafe_double3() TestUtils.AreEqual(double3(1.0, 2.0, 3.0), normalizesafe(double3(8.61e-155, 8.61e-155, 8.61e-155), double3(1.0, 2.0, 3.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_double4() { TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001); @@ -665,7 +665,7 @@ public static void normalizesafe_double4() TestUtils.AreEqual(double4(1.0, 2.0, 3.0, 4.0), normalizesafe(double4(7.45e-155, 7.45e-155, 7.45e-155, 7.45e-155), double4(1.0, 2.0, 3.0, 4.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void normalizesafe_quaternion() { TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -675,7 +675,7 @@ public static void normalizesafe_quaternion() TestUtils.AreEqual(quaternion(1.0f, 2.0f, 3.0f, 4.0f), normalizesafe(quaternion(5.42e-20f, 5.42e-20f, 5.42e-20f, 5.42e-20f), quaternion(1.0f, 2.0f, 3.0f, 4.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f16tof32_float() { TestUtils.AreEqual(0x00000000, asuint(f16tof32(0x0000))); @@ -693,7 +693,7 @@ public static void f16tof32_float() TestUtils.AreEqual(true, isnan(f16tof32(0xFC01))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f16tof32_float2() { TestUtils.AreEqual(uint2(0x00000000, 0x3800C000), asuint(f16tof32(uint2(0x0000, 0x0203)))); @@ -707,7 +707,7 @@ public static void f16tof32_float2() TestUtils.AreEqual(true, all(isnan(f16tof32(uint2(0xFC01, 0xFC01))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f16tof32_float3() { TestUtils.AreEqual(uint3(0x00000000, 0x3800C000, 0x40642000), asuint(f16tof32(uint3(0x0000, 0x0203, 0x4321)))); @@ -719,7 +719,7 @@ public static void f16tof32_float3() TestUtils.AreEqual(true, all(isnan(f16tof32(uint3(0xFC01, 0xFC01, 0xFC01))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f16tof32_float4() { TestUtils.AreEqual(uint4(0x00000000, 0x3800C000, 0x40642000, 0x477FE000), asuint(f16tof32(uint4(0x0000, 0x0203, 0x4321, 0x7BFF)))); @@ -731,7 +731,7 @@ public static void f16tof32_float4() TestUtils.AreEqual(true, all(isnan(f16tof32(uint4(0xFC01, 0xFC01, 0xFC01, 0xFC01))))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f32tof16_float() { TestUtils.AreEqual(0x0000, f32tof16(0.0f)); @@ -751,14 +751,14 @@ public static void f32tof16_float() TestUtils.AreEqual(0xFC00, f32tof16(float.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float_signed_zero() { TestUtils.AreEqual(0x8000, f32tof16(TestUtils.SignedFloatZero())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f32tof16_float2() { TestUtils.AreEqual(uint2(0x0000, 0x0000), f32tof16(float2(0.0f, 2.98e-08f))); @@ -772,14 +772,14 @@ public static void f32tof16_float2() TestUtils.AreEqual(uint2(0xFC00, 0x0000), f32tof16(float2(float.NegativeInfinity, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float2_signed_zero() { TestUtils.AreEqual(uint2(0x8000, 0x8000), f32tof16(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f32tof16_float3() { TestUtils.AreEqual(uint3(0x0000, 0x0000, 0x0001), f32tof16(float3(0.0f, 2.98e-08f, 5.96046448e-08f))); @@ -790,14 +790,14 @@ public static void f32tof16_float3() TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), f32tof16(float3(-65520.0f, float.NegativeInfinity, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float3_signed_zero() { TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), f32tof16(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void f32tof16_float4() { TestUtils.AreEqual(uint4(0x0000, 0x0000, 0x0001, 0x57B6), f32tof16(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f))); @@ -806,14 +806,14 @@ public static void f32tof16_float4() TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), f32tof16(float4(-65520.0f, float.NegativeInfinity, float.NegativeInfinity, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float4_signed_zero() { TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), f32tof16(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reflect_float2() { TestUtils.AreEqual(float2(9.84f, -3.888f), reflect(float2(1.2f, 3.6f), float2(1.5f, -1.3f)), 8, false); @@ -822,7 +822,7 @@ public static void reflect_float2() TestUtils.AreEqual(float2(0.0f, 0.0f), reflect(float2(0.0f, 0.0f), float2(-1.5f, -1.3f)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reflect_float3() { TestUtils.AreEqual(float3(35.88f, -26.456f, 68.872f), reflect(float3(1.2f, 3.6f, -2.8f), float3(1.5f, -1.3f, 3.1f)), 8, false); @@ -831,7 +831,7 @@ public static void reflect_float3() TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), reflect(float3(0.0f, 0.0f, 0.0f), float3(-1.5f, -1.3f, 3.1f)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reflect_float4() { TestUtils.AreEqual(float4(36.51f, -27.002f, 70.174f, -16.178f), reflect(float4(1.2f, 3.6f, -2.8f, 0.3f), float4(1.5f, -1.3f, 3.1f, -0.7f)), 8, false); @@ -841,7 +841,7 @@ public static void reflect_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reflect_double2() { TestUtils.AreEqual(double2(9.84, -3.888), reflect(double2(1.2, 3.6), double2(1.5, -1.3)), 8, false); @@ -850,7 +850,7 @@ public static void reflect_double2() TestUtils.AreEqual(double2(0.0, 0.0), reflect(double2(0.0, 0.0), double2(-1.5, -1.3)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reflect_double3() { TestUtils.AreEqual(double3(35.88, -26.456, 68.872), reflect(double3(1.2, 3.6, -2.8), double3(1.5, -1.3, 3.1)), 8, false); @@ -859,7 +859,7 @@ public static void reflect_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), reflect(double3(0.0, 0.0, 0.0), double3(-1.5f, -1.3, 3.1)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void reflect_double4() { TestUtils.AreEqual(double4(36.51, -27.002, 70.174, -16.178), reflect(double4(1.2, 3.6, -2.8, 0.3), double4(1.5, -1.3, 3.1, -0.7)), 8, false); @@ -869,7 +869,7 @@ public static void reflect_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void refract_float2() { TestUtils.AreEqual(float2(-0.3676186f, 0.9299768f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 0.5f), 8, false); @@ -877,7 +877,7 @@ public static void refract_float2() TestUtils.AreEqual(float2(0.0f, 0.0f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 1.5f)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void refract_float3() { TestUtils.AreEqual(float3(-0.2863437f, 0.8056898f, -0.5185286f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 0.5f), 8, false); @@ -885,7 +885,7 @@ public static void refract_float3() TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 1.5f)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void refract_float4() { TestUtils.AreEqual(float4(-0.302029191645545f, 0.799522577847971f, -0.518952508802814f, -0.015196476378571f), refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.1726139f), 0.5f), 16, false); @@ -894,7 +894,7 @@ public static void refract_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void refract_double2() { TestUtils.AreEqual(double2(-0.367618540673032, 0.929976739623085), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 0.5), 8, false); @@ -902,7 +902,7 @@ public static void refract_double2() TestUtils.AreEqual(double2(0.0, 0.0), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 1.5)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void refract_double3() { TestUtils.AreEqual(double3(-0.286343746291412, 0.805689753507206, -0.518528611485079), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 0.5), 8, false); @@ -910,7 +910,7 @@ public static void refract_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 1.5)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void refract_double4() { TestUtils.AreEqual(double4(-0.302029191645545, 0.799522577847971, -0.518952508802814, -0.015196476378571), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.1726139), 0.5), 16, false); @@ -918,7 +918,7 @@ public static void refract_double4() TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.172613), 1.5)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void project_float2() { var a = float2(-0.161021441221237182617f, 0.429202795028686523438f); @@ -927,7 +927,7 @@ public static void project_float2() TestUtils.AreEqual(float2(1.0f, 0.0f), project(float2(1.0f), float2(1.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void project_float3() { var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f); @@ -936,7 +936,7 @@ public static void project_float3() TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), project(float3(1.0f), float3(1.0f, 0.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void project_float4() { var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f); @@ -945,7 +945,7 @@ public static void project_float4() TestUtils.AreEqual(float4(1.0f, 0.0f, 0.0f, 0.0f), project(float4(1.0f), float4(1.0f, 0.0f, 0.0f, 0.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void projectsafe_float2() { var a = float2(-0.161021441221237182617f, 0.429202795028686523438f); @@ -957,7 +957,7 @@ public static void projectsafe_float2() TestUtils.AreEqual(float2(4.0f), projectsafe(float2(NAN), float2(0.0f), float2(4.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void projectsafe_float3() { var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f); @@ -969,7 +969,7 @@ public static void projectsafe_float3() TestUtils.AreEqual(float3(4.0f), projectsafe(float3(NAN), float3(0.0f), float3(4.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void projectsafe_float4() { var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f); @@ -981,7 +981,7 @@ public static void projectsafe_float4() TestUtils.AreEqual(float4(4.0f), projectsafe(float4(NAN), float4(0.0f), float4(4.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void project_double2() { var a = double2(-0.435219509355847911092, -0.359623376546357509387); @@ -991,7 +991,7 @@ public static void project_double2() TestUtils.AreEqual(double2.zero, projectsafe(a, double2(DBL_MIN_NORMAL))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void project_double3() { var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805); @@ -1001,7 +1001,7 @@ public static void project_double3() TestUtils.AreEqual(double3.zero, projectsafe(a, double3(DBL_MIN_NORMAL))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void project_double4() { var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997); @@ -1011,7 +1011,7 @@ public static void project_double4() TestUtils.AreEqual(double4.zero, projectsafe(a, double4(DBL_MIN_NORMAL))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void projectsafe_double2() { var a = double2(-0.435219509355847911092, -0.359623376546357509387); @@ -1023,7 +1023,7 @@ public static void projectsafe_double2() TestUtils.AreEqual(double2(4.0), projectsafe(double2(NAN_DBL), double2(0.0), double2(4.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void projectsafe_double3() { var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805); @@ -1035,7 +1035,7 @@ public static void projectsafe_double3() TestUtils.AreEqual(double3(4.0), projectsafe(double3(NAN_DBL), double3(0.0), double3(4.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void projectsafe_double4() { var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997); @@ -1047,7 +1047,7 @@ public static void projectsafe_double4() TestUtils.AreEqual(double4(4.0), projectsafe(double4(NAN_DBL), double4(0.0), double4(4.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_float() { float s, c; @@ -1086,7 +1086,7 @@ public static void sincos_float() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_float2() { float2 s, c; @@ -1108,7 +1108,7 @@ public static void sincos_float2() TestUtils.AreEqual(float2(float.NaN, float.NaN), c, 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_float3() { float3 s, c; @@ -1126,7 +1126,7 @@ public static void sincos_float3() TestUtils.AreEqual(float3(float.NaN, float.NaN, float.NaN), c, 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_float4() { float4 s, c; @@ -1140,7 +1140,7 @@ public static void sincos_float4() TestUtils.AreEqual(float4(0.936752141f, float.NaN, float.NaN, float.NaN), c, 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_double() { double s, c; @@ -1177,7 +1177,7 @@ public static void sincos_double() TestUtils.AreEqual(double.NaN, c, 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_double2() { double2 s, c; @@ -1198,7 +1198,7 @@ public static void sincos_double2() TestUtils.AreEqual(double2(double.NaN, double.NaN), c, 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_double3() { double3 s, c; @@ -1216,7 +1216,7 @@ public static void sincos_double3() TestUtils.AreEqual(double3(double.NaN, double.NaN, double.NaN), c, 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sincos_double4() { double4 s, c; @@ -1230,14 +1230,14 @@ public static void sincos_double4() TestUtils.AreEqual(double4(0.93675212753314474, double.NaN, double.NaN, double.NaN), c, 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_int() { TestUtils.AreEqual(-123456789, select(-123456789, 987654321, false)); TestUtils.AreEqual(987654321, select(-123456789, 987654321, true)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_int2() { TestUtils.AreEqual(int2(-123456789, -123456790), select(int2(-123456789, -123456790), int2(987654321, 987654322), false)); @@ -1249,7 +1249,7 @@ public static void select_int2() TestUtils.AreEqual(int2(987654321, 987654322), select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_int3() { TestUtils.AreEqual(int3(-123456789, -123456790, -123456791), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), false)); @@ -1266,7 +1266,7 @@ public static void select_int3() TestUtils.AreEqual(int3(987654321, 987654322, 987654323), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_int4() { TestUtils.AreEqual(int4(-123456789, -123456790, -123456791, -123456792), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), false)); @@ -1293,14 +1293,14 @@ public static void select_int4() TestUtils.AreEqual(int4(987654321, 987654322, 987654323, 987654324), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_uint() { TestUtils.AreEqual(123456789u, select(123456789u, 987654321u, false)); TestUtils.AreEqual(987654321u, select(123456789u, 987654321u, true)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_uint2() { TestUtils.AreEqual(uint2(123456789u, 123456790u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), false)); @@ -1312,7 +1312,7 @@ public static void select_uint2() TestUtils.AreEqual(uint2(987654321u, 987654322u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_uint3() { TestUtils.AreEqual(uint3(123456789u, 123456790u, 123456791u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), false)); @@ -1329,7 +1329,7 @@ public static void select_uint3() TestUtils.AreEqual(uint3(987654321u, 987654322u, 987654323u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_uint4() { TestUtils.AreEqual(uint4(123456789u, 123456790u, 123456791u, 123456792u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), false)); @@ -1356,14 +1356,14 @@ public static void select_uint4() TestUtils.AreEqual(uint4(987654321u, 987654322u, 987654323u, 987654324u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_long() { TestUtils.AreEqual(-12345678910111314L, select(-12345678910111314L, 987654321011121314L, false)); TestUtils.AreEqual(987654321011121314L, select(-12345678910111314L, 987654321011121314L, true)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_ulong() { TestUtils.AreEqual(12345678910111314UL, select(12345678910111314UL, 987654321011121314UL, false)); @@ -1371,14 +1371,14 @@ public static void select_ulong() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_float() { TestUtils.AreEqual(-1234.5f, select(-1234.5f, 9876.25f, false)); TestUtils.AreEqual(9876.25f, select(-1234.5f, 9876.25f, true)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_float2() { TestUtils.AreEqual(float2(-1234.5f, -1235.5f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), false)); @@ -1390,7 +1390,7 @@ public static void select_float2() TestUtils.AreEqual(float2(9876.25f, 9877.25f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_float3() { TestUtils.AreEqual(float3(-1234.5f, -1235.5f, -1236.5f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), false)); @@ -1407,7 +1407,7 @@ public static void select_float3() TestUtils.AreEqual(float3(9876.25f, 9877.25f, 9878.25f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_float4() { TestUtils.AreEqual(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), false)); @@ -1435,14 +1435,14 @@ public static void select_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_double() { TestUtils.AreEqual(-1234.5, select(-1234.5, 9876.25, false)); TestUtils.AreEqual(9876.25, select(-1234.5, 9876.25, true)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_double2() { TestUtils.AreEqual(double2(-1234.5, -1235.5), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), false)); @@ -1454,7 +1454,7 @@ public static void select_double2() TestUtils.AreEqual(double2(9876.25, 9877.25), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_double3() { TestUtils.AreEqual(double3(-1234.5, -1235.5, -1236.5), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), false)); @@ -1471,7 +1471,7 @@ public static void select_double3() TestUtils.AreEqual(double3(9876.25, 9877.25, 9878.25), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void select_double4() { TestUtils.AreEqual(double4(-1234.5, -1235.5, -1236.5, -1237.5), select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), false)); @@ -1499,7 +1499,7 @@ public static void select_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_int() { TestUtils.AreEqual(133, dot(7, 19)); @@ -1508,7 +1508,7 @@ public static void dot_int() TestUtils.AreEqual(667585376, dot(61031, 81312)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_int2() { TestUtils.AreEqual(322, dot(int2(7, 9), int2(19, 21))); @@ -1517,7 +1517,7 @@ public static void dot_int2() TestUtils.AreEqual(1840235232, dot(int2(61031, -12534), int2(-41312, -5312))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_int3() { TestUtils.AreEqual(582, dot(int3(7, 9, 13), int3(19, 21, 20))); @@ -1526,7 +1526,7 @@ public static void dot_int3() TestUtils.AreEqual(1636460279, dot(int3(61031, -12534, 9211), int3(-41312, -5312, -22123))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_int4() { TestUtils.AreEqual(990, dot(int4(7, 9, 13, 17), int4(19, 21, 20, 24))); @@ -1536,28 +1536,28 @@ public static void dot_int4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_uint() { TestUtils.AreEqual(133u, dot(7u, 19u)); TestUtils.AreEqual(667585376u, dot(61031u, 81312u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_uint2() { TestUtils.AreEqual(322, dot(uint2(7u, 9u), uint2(19u, 21u))); TestUtils.AreEqual(734165984u, dot(uint2(61031u, 12534u), uint2(81312u, 5312u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_uint3() { TestUtils.AreEqual(582u, dot(uint3(7u, 9u, 13u), uint3(19u, 21u, 20u))); TestUtils.AreEqual(937940937u, dot(uint3(61031u, 12534u, 9211u), uint3(81312u, 5312u, 22123u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_uint4() { TestUtils.AreEqual(990u, dot(uint4(7u, 9u, 13u, 17u), uint4(19u, 21u, 20u, 24u))); @@ -1565,7 +1565,7 @@ public static void dot_uint4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_float() { TestUtils.AreEqual(7.32f, dot(1.2f, 6.1f), 1, false); @@ -1576,7 +1576,7 @@ public static void dot_float() TestUtils.AreEqual(float.NegativeInfinity, dot(1.2e19f, -6.1e19f), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_float2() { TestUtils.AreEqual(57.92f, dot(float2(1.2f, 5.5f), float2(6.1f, 9.2f)), 1, false); @@ -1587,7 +1587,7 @@ public static void dot_float2() TestUtils.AreEqual(float.NegativeInfinity, dot(float2(-1.2e18f, 5.5e18f), float2(6.1e19f, -9.2e19f)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_float3() { TestUtils.AreEqual(67.1f, dot(float3(1.2f, 5.5f, 3.4f), float3(6.1f, 9.2f, 2.7f)), 8, false); @@ -1598,7 +1598,7 @@ public static void dot_float3() TestUtils.AreEqual(float.NegativeInfinity, dot(float3(-1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e19f, -9.2e19f, -2.7e19f)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_float4() { TestUtils.AreEqual(68.57f, dot(float4(1.2f, 5.5f, 3.4f, 4.9f), float4(6.1f, 9.2f, 2.7f, 0.3f)), 8, false); @@ -1620,7 +1620,7 @@ public static void dot_double() TestUtils.AreEqual(double.NegativeInfinity, dot(1.2e19, -6.1e19), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_double2() { TestUtils.AreEqual(57.92, dot(double2(1.2, 5.5), double2(6.1, 9.2)), 1, false); @@ -1631,7 +1631,7 @@ public static void dot_double2() TestUtils.AreEqual(double.NegativeInfinity, dot(double2(-1.2e153, 5.5e153), double2(6.1e154, -9.2e154)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_double3() { TestUtils.AreEqual(67.1, dot(double3(1.2, 5.5, 3.4), double3(6.1, 9.2, 2.7)), 8, false); @@ -1642,7 +1642,7 @@ public static void dot_double3() TestUtils.AreEqual(double.NegativeInfinity, dot(double3(-1.2e153, 5.5e153, 3.4e153), double3(6.1e154, -9.2e154, -2.7e154)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void dot_double4() { TestUtils.AreEqual(68.57, dot(double4(1.2, 5.5, 3.4, 4.9), double4(6.1, 9.2, 2.7, 0.3)), 8, false); @@ -1653,7 +1653,7 @@ public static void dot_double4() TestUtils.AreEqual(double.NegativeInfinity, dot(double4(-1.2e153, 5.5e153, 3.4e153, -4.9e153), double4(6.1e154, -9.2e154, -2.7e154, 3e153)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_int2() { TestUtils.AreEqual(100, cmin(int2(100, 200))); @@ -1664,7 +1664,7 @@ public static void cmin_int2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_int3() { TestUtils.AreEqual(100, cmin(int3(100, 200, 300))); @@ -1675,7 +1675,7 @@ public static void cmin_int3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_int4() { TestUtils.AreEqual(100, cmin(int4(100, 200, 300, 400))); @@ -1685,7 +1685,7 @@ public static void cmin_int4() TestUtils.AreEqual(int.MinValue, cmin(int4(int.MaxValue, int.MinValue, 0, 19))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_uint2() { TestUtils.AreEqual(100u, cmin(uint2(100u, 200u))); @@ -1694,7 +1694,7 @@ public static void cmin_uint2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_uint3() { TestUtils.AreEqual(100u, cmin(uint3(100u, 200u, 300u))); @@ -1703,7 +1703,7 @@ public static void cmin_uint3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_uint4() { TestUtils.AreEqual(100u, cmin(uint4(100u, 200u, 300u, 400u))); @@ -1711,7 +1711,7 @@ public static void cmin_uint4() TestUtils.AreEqual(uint.MinValue, cmin(uint4(19u, uint.MinValue, uint.MaxValue, 7u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_float2() { TestUtils.AreEqual(-0.5f, cmin(float2(5.2f, -0.5f))); @@ -1730,7 +1730,7 @@ public static void cmin_float2() TestUtils.AreEqual(float.NegativeInfinity, cmin(float2(float.NaN, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_float3() { TestUtils.AreEqual(-1.2f, cmin(float3(5.2f, -0.5f, -1.2f))); @@ -1750,7 +1750,7 @@ public static void cmin_float3() TestUtils.AreEqual(float.NegativeInfinity, cmin(float3(float.NaN, float.NaN, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_float4() { TestUtils.AreEqual(-1.2f, cmin(float4(5.2f, -0.5f, -1.2f, 2.3f))); @@ -1773,7 +1773,7 @@ public static void cmin_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_double2() { TestUtils.AreEqual(-0.5, cmin(double2(5.2, -0.5))); @@ -1793,7 +1793,7 @@ public static void cmin_double2() TestUtils.AreEqual(double.NegativeInfinity, cmin(double2(double.NaN, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_double3() { TestUtils.AreEqual(-1.2, cmin(double3(5.2, -0.5, -1.2))); @@ -1814,7 +1814,7 @@ public static void cmin_double3() TestUtils.AreEqual(double.NegativeInfinity, cmin(double3(double.NaN, double.NaN, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmin_double4() { TestUtils.AreEqual(-1.2, cmin(double4(5.2, -0.5, -1.2, 2.3))); @@ -1839,7 +1839,7 @@ public static void cmin_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_int2() { TestUtils.AreEqual(200, cmax(int2(100, 200))); @@ -1850,7 +1850,7 @@ public static void cmax_int2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_int3() { TestUtils.AreEqual(300, cmax(int3(100, 200, 300))); @@ -1861,7 +1861,7 @@ public static void cmax_int3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_int4() { TestUtils.AreEqual(400, cmax(int4(100, 200, 300, 400))); @@ -1871,7 +1871,7 @@ public static void cmax_int4() TestUtils.AreEqual(int.MaxValue, cmax(int4(int.MaxValue, int.MinValue, 0, 19))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_uint2() { TestUtils.AreEqual(200u, cmax(uint2(100u, 200u))); @@ -1880,7 +1880,7 @@ public static void cmax_uint2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_uint3() { TestUtils.AreEqual(300u, cmax(uint3(100u, 200u, 300u))); @@ -1889,7 +1889,7 @@ public static void cmax_uint3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_uint4() { TestUtils.AreEqual(400u, cmax(uint4(100u, 200u, 300u, 400u))); @@ -1897,7 +1897,7 @@ public static void cmax_uint4() TestUtils.AreEqual(uint.MaxValue, cmax(uint4(19u, uint.MinValue, uint.MaxValue, 7u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_float2() { TestUtils.AreEqual(5.2f, cmax(float2(5.2f, -0.5f))); @@ -1916,7 +1916,7 @@ public static void cmax_float2() TestUtils.AreEqual(float.NegativeInfinity, cmax(float2(float.NaN, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_float3() { TestUtils.AreEqual(5.2f, cmax(float3(5.2f, -0.5f, -1.2f))); @@ -1936,7 +1936,7 @@ public static void cmax_float3() TestUtils.AreEqual(float.NegativeInfinity, cmax(float3(float.NaN, float.NaN, float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_float4() { TestUtils.AreEqual(5.2f, cmax(float4(5.2f, -0.5f, -1.2f, 2.3f))); @@ -1959,7 +1959,7 @@ public static void cmax_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_double2() { TestUtils.AreEqual(5.2, cmax(double2(5.2, -0.5))); @@ -1979,7 +1979,7 @@ public static void cmax_double2() TestUtils.AreEqual(double.NegativeInfinity, cmax(double2(double.NaN, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_double3() { TestUtils.AreEqual(5.2, cmax(double3(5.2, -0.5, -1.2))); @@ -2000,7 +2000,7 @@ public static void cmax_double3() TestUtils.AreEqual(double.NegativeInfinity, cmax(double3(double.NaN, double.NaN, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cmax_double4() { TestUtils.AreEqual(5.2, cmax(double4(5.2, -0.5, -1.2, 2.3))); @@ -2024,7 +2024,7 @@ public static void cmax_double4() TestUtils.AreEqual(double.NegativeInfinity, cmax(double4(double.NaN, double.NaN, double.NaN, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_int2() { TestUtils.AreEqual(300, csum(int2(100, 200))); @@ -2035,7 +2035,7 @@ public static void csum_int2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_int3() { TestUtils.AreEqual(600, csum(int3(100, 200, 300))); @@ -2046,7 +2046,7 @@ public static void csum_int3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_int4() { TestUtils.AreEqual(1000, csum(int4(100, 200, 300, 400))); @@ -2056,7 +2056,7 @@ public static void csum_int4() TestUtils.AreEqual(-1, csum(int4(int.MaxValue, int.MinValue, 0, 0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_uint2() { TestUtils.AreEqual(300u, csum(uint2(100u, 200u))); @@ -2064,7 +2064,7 @@ public static void csum_uint2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_uint3() { TestUtils.AreEqual(600u, csum(uint3(100u, 200u, 300u))); @@ -2072,14 +2072,14 @@ public static void csum_uint3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_uint4() { TestUtils.AreEqual(1000u, csum(uint4(100u, 200u, 300u, 400u))); TestUtils.AreEqual(36u, csum(uint4(uint.MaxValue, 7u, 11u, 19u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_float2() { TestUtils.AreEqual(0.7f, csum(float2(2.2f, -1.5f)), 4, false); @@ -2102,7 +2102,7 @@ public static void csum_float2() TestUtils.AreEqual(float.NegativeInfinity, csum(float2(-1.0f, float.NegativeInfinity)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_float3() { TestUtils.AreEqual(1.9f, csum(float3(2.2f, -1.5f, 1.2f)), 4, false); @@ -2126,7 +2126,7 @@ public static void csum_float3() TestUtils.AreEqual(float.NegativeInfinity, csum(float3(-2.0f, 1.0f, float.NegativeInfinity)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_float4() { TestUtils.AreEqual(1.2f, csum(float4(2.2f, -1.5f, 1.2f, -0.7f)), 4, false); @@ -2153,7 +2153,7 @@ public static void csum_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_double2() { TestUtils.AreEqual(0.7, csum(double2(2.2, -1.5)), 4, false); @@ -2176,7 +2176,7 @@ public static void csum_double2() TestUtils.AreEqual(double.NegativeInfinity, csum(double2(-1.0, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_double3() { TestUtils.AreEqual(1.9, csum(double3(2.2, -1.5, 1.2)), 4, false); @@ -2200,7 +2200,7 @@ public static void csum_double3() TestUtils.AreEqual(double.NegativeInfinity, csum(double3(-2.0, 1.0, double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void csum_double4() { TestUtils.AreEqual(1.2, csum(double4(2.2, -1.5, 1.2, -0.7)), 4, false); @@ -2227,7 +2227,7 @@ public static void csum_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_bool2() { TestUtils.AreEqual(false, any(bool2(false, false))); @@ -2236,7 +2236,7 @@ public static void any_bool2() TestUtils.AreEqual(true, any(bool2(true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_bool3() { TestUtils.AreEqual(false, any(bool3(false, false, false))); @@ -2250,7 +2250,7 @@ public static void any_bool3() TestUtils.AreEqual(true, any(bool3(true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_bool4() { TestUtils.AreEqual(false, any(bool4(false, false, false, false))); @@ -2274,7 +2274,7 @@ public static void any_bool4() TestUtils.AreEqual(true, any(bool4(true, true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_int2() { TestUtils.AreEqual(false, any(int2(0, 0))); @@ -2284,7 +2284,7 @@ public static void any_int2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_int3() { TestUtils.AreEqual(false, any(int3(0, 0, 0))); @@ -2298,7 +2298,7 @@ public static void any_int3() TestUtils.AreEqual(true, any(int3(-121, 100, 322))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_int4() { TestUtils.AreEqual(false, any(int4(0, 0, 0, 0))); @@ -2323,7 +2323,7 @@ public static void any_int4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_uint2() { TestUtils.AreEqual(false, any(uint2(0u, 0u))); @@ -2333,7 +2333,7 @@ public static void any_uint2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_uint3() { TestUtils.AreEqual(false, any(uint3(0u, 0u, 0u))); @@ -2347,7 +2347,7 @@ public static void any_uint3() TestUtils.AreEqual(true, any(uint3(121u, 100u, 322u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_uint4() { TestUtils.AreEqual(false, any(uint4(0u, 0u, 0u, 0u))); @@ -2372,7 +2372,7 @@ public static void any_uint4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_float2() { //TestUtils.AreEqual(true, any(float2(0, float.NaN))); // TODO: doesn't work with burst @@ -2384,7 +2384,7 @@ public static void any_float2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_float3() { //TestUtils.AreEqual(true, any(float3(0.0f, float.NaN, 0.0f))); // TODO: doesn't work with burst @@ -2400,7 +2400,7 @@ public static void any_float3() TestUtils.AreEqual(true, any(float3(121.2f, 100.0f, -32.2f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_float4() { TestUtils.AreEqual(false, any(float4(0.0f, 0.0f, 0.0f, 0.0f))); @@ -2424,7 +2424,7 @@ public static void any_float4() TestUtils.AreEqual(true, any(float4(55.0f, 66.0f, 5000.0f, 10000.2f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_double2() { //TestUtils.AreEqual(true, any(double2(0, double.NaN))); // TODO: doesn't work with burst. @@ -2436,7 +2436,7 @@ public static void any_double2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_double3() { //TestUtils.AreEqual(true, any(double3(0.0, double.NaN, 0.0))); // TODO: doesn't work with burst @@ -2452,7 +2452,7 @@ public static void any_double3() TestUtils.AreEqual(true, any(double3(121.2, 100.0, -32.2))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void any_double4() { TestUtils.AreEqual(false, any(double4(0.0, 0.0, 0.0, 0.0))); @@ -2477,7 +2477,7 @@ public static void any_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_bool2() { TestUtils.AreEqual(false, all(bool2(false, false))); @@ -2486,7 +2486,7 @@ public static void all_bool2() TestUtils.AreEqual(true, all(bool2(true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_bool3() { TestUtils.AreEqual(false, all(bool3(false, false, false))); @@ -2500,7 +2500,7 @@ public static void all_bool3() TestUtils.AreEqual(true, all(bool3(true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_bool4() { TestUtils.AreEqual(false, all(bool4(false, false, false, false))); @@ -2524,7 +2524,7 @@ public static void all_bool4() TestUtils.AreEqual(true, all(bool4(true, true, true, true))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_int2() { TestUtils.AreEqual(false, all(int2(0, 0))); @@ -2533,7 +2533,7 @@ public static void all_int2() TestUtils.AreEqual(true, all(int2(2, int.MinValue))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_int3() { TestUtils.AreEqual(false, all(int3(0, 0, 0))); @@ -2547,7 +2547,7 @@ public static void all_int3() TestUtils.AreEqual(true, all(int3(-121, 100, 322))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_int4() { TestUtils.AreEqual(false, all(int4(0, 0, 0, 0))); @@ -2572,7 +2572,7 @@ public static void all_int4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_uint2() { TestUtils.AreEqual(false, all(uint2(0u, 0u))); @@ -2582,7 +2582,7 @@ public static void all_uint2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_uint3() { TestUtils.AreEqual(false, all(uint3(0u, 0u, 0u))); @@ -2596,7 +2596,7 @@ public static void all_uint3() TestUtils.AreEqual(true, all(uint3(121u, 100u, 322u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_uint4() { TestUtils.AreEqual(false, all(uint4(0u, 0u, 0u, 0u))); @@ -2621,7 +2621,7 @@ public static void all_uint4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_float2() { TestUtils.AreEqual(true, all(float2(float.NaN, float.NaN))); @@ -2633,7 +2633,7 @@ public static void all_float2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_float3() { TestUtils.AreEqual(true, all(float3(float.NaN, float.NaN, float.NaN))); @@ -2649,7 +2649,7 @@ public static void all_float3() TestUtils.AreEqual(true, all(float3(121.2f, 100.0f, -32.2f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_float4() { TestUtils.AreEqual(true, all(float4(float.NaN, float.NaN, float.NaN, float.NaN))); @@ -2675,7 +2675,7 @@ public static void all_float4() TestUtils.AreEqual(true, all(float4(55.0f, 66.0f, 5000.0f, 10000.2f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_double2() { TestUtils.AreEqual(true, all(double2(double.NaN, double.NaN))); @@ -2687,7 +2687,7 @@ public static void all_double2() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_double3() { TestUtils.AreEqual(true, all(double3(double.NaN, double.NaN, double.NaN))); @@ -2703,7 +2703,7 @@ public static void all_double3() TestUtils.AreEqual(true, all(double3(121.2, 100.0, -32.2))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void all_double4() { TestUtils.AreEqual(true, all(double4(double.NaN, double.NaN, double.NaN, double.NaN))); @@ -2730,7 +2730,7 @@ public static void all_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void length_float2() { TestUtils.AreEqual(0.0f, length(float2(0.0f, 0.0f)), 0, false); @@ -2743,7 +2743,7 @@ public static void length_float2() TestUtils.AreEqual(double.PositiveInfinity, length(float2(-1.2e19f, -2.6e19f)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void length_float3() { TestUtils.AreEqual(0.0f, length(float3(0.0f, 0.0f, 0.0f)), 0, false); @@ -2756,7 +2756,7 @@ public static void length_float3() TestUtils.AreEqual(float.PositiveInfinity, length(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void length_float4() { TestUtils.AreEqual(0.0f, length(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false); @@ -2770,7 +2770,7 @@ public static void length_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void length_double2() { TestUtils.AreEqual(0.0, length(double2(0.0, 0.0)), 0, false); @@ -2782,7 +2782,7 @@ public static void length_double2() TestUtils.AreEqual(2.86356421265527063e153, length(double2(-1.2e153, 2.6e153)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void length_double3() { TestUtils.AreEqual(0.0, length(double3(0.0, 0.0, 0.0)), 0, false); @@ -2794,7 +2794,7 @@ public static void length_double3() TestUtils.AreEqual(3.6110940170535577e153, length(double3(-1.2e153, 2.6e153, 2.2e153)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void length_double4() { TestUtils.AreEqual(0.0, length(double4(0.0, 0.0, 0.0, 0.0)), 0, false); @@ -2807,7 +2807,7 @@ public static void length_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lengthsq_float2() { TestUtils.AreEqual(0.0f, lengthsq(float2(0.0f, 0.0f)), 0, false); @@ -2819,7 +2819,7 @@ public static void lengthsq_float2() TestUtils.AreEqual(8.2e36f, lengthsq(float2(-1.2e18f, 2.6e18f)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lengthsq_float3() { TestUtils.AreEqual(0.0f, lengthsq(float3(0.0f, 0.0f, 0.0f)), 0, false); @@ -2832,7 +2832,7 @@ public static void lengthsq_float3() TestUtils.AreEqual(float.PositiveInfinity, lengthsq(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lengthsq_float4() { TestUtils.AreEqual(0.0f, lengthsq(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false); @@ -2846,7 +2846,7 @@ public static void lengthsq_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lengthsq_double2() { TestUtils.AreEqual(0.0, lengthsq(double2(0.0, 0.0)), 0, false); @@ -2859,7 +2859,7 @@ public static void lengthsq_double2() TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double2(-1.2e154, -2.6e154)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lengthsq_double3() { TestUtils.AreEqual(0.0, lengthsq(double3(0.0, 0.0, 0.0)), 0, false); @@ -2872,7 +2872,7 @@ public static void lengthsq_double3() TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double3(-1.2e154, -2.6e154, 2.2e154)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lengthsq_double4() { TestUtils.AreEqual(0.0, lengthsq(double4(0.0, 0.0, 0.0, 0.0)), 0, false); @@ -2888,7 +2888,7 @@ public static void lengthsq_double4() - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distance_float2() { TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false); @@ -2902,7 +2902,7 @@ public static void distance_float2() TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distance_float3() { TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false); @@ -2916,7 +2916,7 @@ public static void distance_float3() TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distance_float4() { TestUtils.AreEqual(0.0, distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false); @@ -2931,7 +2931,7 @@ public static void distance_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distance_double2() { TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false); @@ -2944,7 +2944,7 @@ public static void distance_double2() TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distance_double3() { TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false); @@ -2957,7 +2957,7 @@ public static void distance_double3() TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distance_double4() { TestUtils.AreEqual(0.0, distance(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false); @@ -2970,7 +2970,7 @@ public static void distance_double4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distancesq_float2() { TestUtils.AreEqual(0.0f, distancesq(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false); @@ -2982,7 +2982,7 @@ public static void distancesq_float2() TestUtils.AreEqual(float.PositiveInfinity, distancesq(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distancesq_float3() { TestUtils.AreEqual(0.0f, distancesq(float3(1.3f, -2.4f, 5.7f), float3(1.3f, -2.4f, 5.7f)), 0, false); @@ -2995,7 +2995,7 @@ public static void distancesq_float3() TestUtils.AreEqual(float.PositiveInfinity, distancesq(float3(1.3f, -2.4f, 5.7f), float3(-5.3f, float.PositiveInfinity, 4.7f)), 0, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distancesq_float4() { TestUtils.AreEqual(0.0f, distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false); @@ -3008,7 +3008,7 @@ public static void distancesq_float4() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distancesq_double2() { TestUtils.AreEqual(0.0, distancesq(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false); @@ -3022,7 +3022,7 @@ public static void distancesq_double2() TestUtils.AreEqual(double.PositiveInfinity, distancesq(double2(1.3, double.NegativeInfinity), double2(-5.3, 4.3)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distancesq_double3() { TestUtils.AreEqual(0.0, distancesq(double3(1.3, -2.4, 5.7), double3(1.3, -2.4, 5.7)), 0, false); @@ -3036,7 +3036,7 @@ public static void distancesq_double3() TestUtils.AreEqual(double.PositiveInfinity, distancesq(double3(1.3, double.NegativeInfinity, 5.7), double3(-5.3, 4.3, 4.7)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void distancesq_double4() { TestUtils.AreEqual(0.0, distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false); @@ -3050,7 +3050,7 @@ public static void distancesq_double4() TestUtils.AreEqual(double.PositiveInfinity, distancesq(double4(1.3, double.NegativeInfinity, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void epsilon_float() { float next = asfloat(asuint(1.0f) + 1); @@ -3059,7 +3059,7 @@ public static void epsilon_float() TestUtils.IsTrue(Single.Epsilon != EPSILON); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void epsilon_double() { double next = asdouble(aslong(1.0) + 1); @@ -3068,7 +3068,7 @@ public static void epsilon_double() TestUtils.IsTrue(Double.Epsilon != EPSILON_DBL); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void nan_float() { TestUtils.IsFalse(0.0f == NAN); @@ -3093,7 +3093,7 @@ public static void nan_float() TestUtils.IsTrue(nan1 != nan2); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void nan_double() { TestUtils.IsFalse(0.0 == NAN_DBL); @@ -3118,7 +3118,7 @@ public static void nan_double() TestUtils.IsTrue(nan1 != nan2); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void infinity_float() { TestUtils.IsTrue(-INFINITY != INFINITY); @@ -3126,7 +3126,7 @@ public static void infinity_float() TestUtils.IsFalse(isfinite(INFINITY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void infinity_double() { TestUtils.IsTrue(-INFINITY_DBL != INFINITY_DBL); @@ -3134,7 +3134,7 @@ public static void infinity_double() TestUtils.IsFalse(isfinite(INFINITY_DBL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void helper_axes() { TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), right()); @@ -3145,7 +3145,7 @@ public static void helper_axes() TestUtils.AreEqual(float3(0.0f, 0.0f, -1.0f), back()); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float_signed_zero() { @@ -3153,21 +3153,21 @@ public static void rcp_float_signed_zero() TestUtils.AreEqual(TestUtils.SignedFloatZero(), rcp(float.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float2_signed_zero() { TestUtils.AreEqual(float2(float.NegativeInfinity, TestUtils.SignedFloatZero()), rcp(float2(TestUtils.SignedFloatZero(), float.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float3_signed_zero() { TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatZero(), float.NegativeInfinity), rcp(float3(TestUtils.SignedFloatZero(), float.NegativeInfinity, TestUtils.SignedFloatZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float4_signed_zero() { @@ -3175,7 +3175,7 @@ public static void rcp_float4_signed_zero() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double_signed_zero() { @@ -3183,28 +3183,28 @@ public static void rcp_double_signed_zero() TestUtils.AreEqual(TestUtils.SignedDoubleZero(), rcp(double.NegativeInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double2_signed_zero() { TestUtils.AreEqual(double2(double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double2(TestUtils.SignedDoubleZero(), double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double3_signed_zero() { TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity), rcp(double3(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double4_signed_zero() { TestUtils.AreEqual(double4(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double4(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] unsafe public static void compress_test() { int4 value = int4(0x12345678, 0x2468ACE0, 0x369BE147, 0x48C059D1); @@ -3250,7 +3250,7 @@ unsafe public static void compress_test() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] unsafe public static void compress_uint4_test() { uint4 value = uint4(0x12345678u, 0x2468ACE0u, 0x369BE147u, 0x48C059D1u); @@ -3296,7 +3296,7 @@ unsafe public static void compress_uint4_test() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] unsafe public static void compress_float4_test() { float4 value = float4(float.PositiveInfinity, EPSILON, PI, -0.25f); @@ -3342,7 +3342,7 @@ unsafe public static void compress_float4_test() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_float() { TestUtils.AreEqual(0.0f, math.square(0.0f)); @@ -3370,7 +3370,7 @@ public static void square_float() TestUtils.AreEqual(float.PositiveInfinity, math.square(-18446744073709551616.0f)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_float2() { TestUtils.AreEqual(new float2(0.0f), math.square(new float2(0.0f))); @@ -3401,7 +3401,7 @@ public static void square_float2() TestUtils.AreEqual(new float2(0.272176146507263183594f, 96307.6015625f), math.square(new float2(0.521705031394958496094f, -310.33465576171875f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_float3() { TestUtils.AreEqual(new float3(0.0f), math.square(new float3(0.0f))); @@ -3432,7 +3432,7 @@ public static void square_float3() TestUtils.AreEqual(new float3(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f), math.square(new float3(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_float4() { TestUtils.AreEqual(new float4(0.0f), math.square(new float4(0.0f))); @@ -3463,7 +3463,7 @@ public static void square_float4() TestUtils.AreEqual(new float4(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f, 152764.28125f), math.square(new float4(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f, 390.8507080078125f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_double() { TestUtils.AreEqual(0.0, math.square(0.0)); @@ -3491,7 +3491,7 @@ public static void square_double() TestUtils.AreEqual(double.PositiveInfinity, math.square(-1.34078079299425970996e+154)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_double2() { TestUtils.AreEqual(new double2(0.0), math.square(new double2(0.0))); @@ -3522,7 +3522,7 @@ public static void square_double2() TestUtils.AreEqual(new double2(0.272176139782814630053, 96307.5985667444765568), math.square(new double2(0.521705031394958496094, -310.33465576171875))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_double3() { TestUtils.AreEqual(new double3(0.0), math.square(new double3(0.0))); @@ -3553,7 +3553,7 @@ public static void square_double3() TestUtils.AreEqual(new double3(0.272176139782814630053, 96307.5985667444765568, 5591.63402314303675666), math.square(new double3(0.521705031394958496094, -310.33465576171875, -74.77722930908203125))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_double4() { TestUtils.AreEqual(new double4(0.0), math.square(new double4(0.0))); @@ -3584,7 +3584,7 @@ public static void square_double4() TestUtils.AreEqual(new double4(0.272176139782814630053, 96307.5985667444765568 /*96307.5985667444765568*/, 5591.63402314303675666 /*5591.6337890625*/, 152764.275950208306313 /*152764.28125*/), math.square(new double4(0.521705031394958496094, -310.33465576171875, -74.77722930908203125, 390.8507080078125))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_int() { TestUtils.AreEqual(0, math.square(0)); @@ -3612,7 +3612,7 @@ public static void square_int() TestUtils.AreEqual(0, math.square(-2147483648)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_int2() { TestUtils.AreEqual(new int2(0), math.square(new int2(0))); @@ -3643,7 +3643,7 @@ public static void square_int2() TestUtils.AreEqual(new int2(2121580241, -685235535), math.square(new int2(-831443639, 1415191751))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_int3() { TestUtils.AreEqual(new int3(0), math.square(new int3(0))); @@ -3674,7 +3674,7 @@ public static void square_int3() TestUtils.AreEqual(new int3(2121580241, -685235535, 468048505), math.square(new int3(-831443639, 1415191751, -178100469))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_int4() { TestUtils.AreEqual(new int4(0), math.square(new int4(0))); @@ -3705,7 +3705,7 @@ public static void square_int4() TestUtils.AreEqual(new int4(2121580241, -685235535, 468048505, -1902728316), math.square(new int4(-831443639, 1415191751, -178100469, 1331775970))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_uint() { TestUtils.AreEqual(0u, math.square(0u)); @@ -3723,7 +3723,7 @@ public static void square_uint() TestUtils.AreEqual(2356482048u, math.square(123456u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_uint2() { TestUtils.AreEqual(new uint2(0u), math.square(new uint2(0u))); @@ -3744,7 +3744,7 @@ public static void square_uint2() TestUtils.AreEqual(new uint2(3982663844u, 503153673u), math.square(new uint2(779359642u, 2488899075u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_uint3() { TestUtils.AreEqual(new uint3(0u), math.square(new uint3(0u))); @@ -3765,7 +3765,7 @@ public static void square_uint3() TestUtils.AreEqual(new uint3(3982663844u, 503153673u, 4101817232u), math.square(new uint3(779359642u, 2488899075u, 407772844u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void square_uint4() { TestUtils.AreEqual(new uint4(0u), math.square(new uint4(0u))); @@ -3809,7 +3809,7 @@ static double OrthonormalBasisSquaredError(double3 v1, double3 v2, double3 v3) // "Building an Orthonormal Basis, Revisited" table 1. private const double kOrthonormalBasisSqErrorTolerance = 1.04e-7d; - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void orthonormal_basis_float() { var random = new Random(8189782u); @@ -3824,7 +3824,7 @@ public static void orthonormal_basis_float() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void orthonormal_basis_double() { var random = new Random(99917872u); @@ -3839,7 +3839,7 @@ public static void orthonormal_basis_double() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void chgsign_float() { float c = chgsign(1f, -1f); @@ -3901,7 +3901,7 @@ public static void chgsign_float() TestUtils.AreEqual(asuint(TestUtils.SignedFloatZero()), asuint(c)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void chgsign_float2() { float2 c = chgsign(float2(1f, -2f), float2(-1f, 23.548f)); @@ -3936,7 +3936,7 @@ public static void chgsign_float2() TestUtils.AreEqual(asuint(math.float2(TestUtils.SignedFloatZero())), asuint(c)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void chgsign_float3() { float3 c = chgsign(float3(1f, -2f, 3f), float3(-1f, 23.548f, -0f)); @@ -3971,7 +3971,7 @@ public static void chgsign_float3() TestUtils.AreEqual(asuint(math.float3(TestUtils.SignedFloatZero())), asuint(c)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void chgsign_float4() { float4 c = chgsign(float4(1f, 2f, 3f, -4f), float4(-1f, 0f, -0f, -23.56f)); @@ -4006,7 +4006,7 @@ public static void chgsign_float4() TestUtils.AreEqual(asuint(math.float4(TestUtils.SignedFloatZero())), asuint(c)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static unsafe void quaternion_to_euler() { const float epsilon = 0.0045f; @@ -4079,7 +4079,7 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order) } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mulScale() { var tolerance = 1e-5f; @@ -4101,7 +4101,7 @@ public static void mulScale() TestUtils.AreEqual(expected, actual, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void scaleMul() { var tolerance = 1e-5f; @@ -4123,7 +4123,7 @@ public static void scaleMul() TestUtils.AreEqual(expected, actual, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void piDoubleConstants() { var expectedPi = 3.141592653589793116; @@ -4133,7 +4133,7 @@ public static void piDoubleConstants() TestUtils.AreEqual(expectedPi * 2.0, TAU_DBL); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void piSingleConstants() { var expectedPi = 3.141592653589793116f; @@ -4143,7 +4143,7 @@ public static void piSingleConstants() TestUtils.AreEqual(expectedPi * 2.0f, TAU); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void toDegreesConstants() { TestUtils.AreEqual(360.0, PI2_DBL * TODEGREES_DBL); @@ -4157,7 +4157,7 @@ public static void toDegreesConstants() TestUtils.AreEqual(90.0f, PIHALF * TODEGREES); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void toRadiansConstants() { TestUtils.AreEqual(PI2_DBL, 360.0 * TORADIANS_DBL); @@ -4171,7 +4171,7 @@ public static void toRadiansConstants() TestUtils.AreEqual(PIHALF, 90.0f * TORADIANS); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degreesConversionGivesSameResult() { int n = 360; @@ -4184,7 +4184,7 @@ public static void degreesConversionGivesSameResult() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radiansConversionGivesSameResult() { int n = 360; diff --git a/src/Tests/Tests/Shared/TestMath.gen.cs b/src/Tests/Tests/Shared/TestMath.gen.cs index 3a803b97..1a8e3253 100644 --- a/src/Tests/Tests/Shared/TestMath.gen.cs +++ b/src/Tests/Tests/Shared/TestMath.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestMath { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_int() { TestUtils.AreEqual(0, abs(0)); @@ -25,7 +25,7 @@ public static void abs_int() TestUtils.AreEqual(-2147483648, abs(-2147483648)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_int2() { TestUtils.AreEqual(int2(0, 7), abs(int2(0, -7))); @@ -33,21 +33,21 @@ public static void abs_int2() TestUtils.AreEqual(int2(-2147483648, -2147483648), abs(int2(-2147483648, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_int3() { TestUtils.AreEqual(int3(0, 7, 11), abs(int3(0, -7, 11))); TestUtils.AreEqual(int3(2147483647, -2147483648, -2147483648), abs(int3(-2147483647, -2147483648, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_int4() { TestUtils.AreEqual(int4(0, 7, 11, 2147483647), abs(int4(0, -7, 11, -2147483647))); TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -2147483648), abs(int4(-2147483648, -2147483648, -2147483648, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_float() { TestUtils.AreEqual(0f, abs(0f)); @@ -57,7 +57,7 @@ public static void abs_float() TestUtils.AreEqual(float.PositiveInfinity, abs(float.PositiveInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_float2() { TestUtils.AreEqual(float2(0f, 1.1f), abs(float2(0f, -1.1f))); @@ -65,21 +65,21 @@ public static void abs_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), abs(float2(float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_float3() { TestUtils.AreEqual(float3(0f, 1.1f, 2.2f), abs(float3(0f, -1.1f, 2.2f))); TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_float4() { TestUtils.AreEqual(float4(0f, 1.1f, 2.2f, float.PositiveInfinity), abs(float4(0f, -1.1f, 2.2f, float.NegativeInfinity))); TestUtils.AreEqual(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_double() { TestUtils.AreEqual(0.0, abs(0.0)); @@ -89,7 +89,7 @@ public static void abs_double() TestUtils.AreEqual(double.PositiveInfinity, abs(double.PositiveInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_double2() { TestUtils.AreEqual(double2(0.0, 1.1), abs(double2(0.0, -1.1))); @@ -97,21 +97,21 @@ public static void abs_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), abs(double2(double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_double3() { TestUtils.AreEqual(double3(0.0, 1.1, 2.2), abs(double3(0.0, -1.1, 2.2))); TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void abs_double4() { TestUtils.AreEqual(double4(0.0, 1.1, 2.2, double.PositiveInfinity), abs(double4(0.0, -1.1, 2.2, double.NegativeInfinity))); TestUtils.AreEqual(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_float() { TestUtils.AreEqual(false, isfinite(TestUtils.SignedFloatQNaN())); @@ -125,7 +125,7 @@ public static void isfinite_float() TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_float2() { TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity))); @@ -135,7 +135,7 @@ public static void isfinite_float2() TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_float3() { TestUtils.AreEqual(bool3(false, false, true), isfinite(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue))); @@ -143,7 +143,7 @@ public static void isfinite_float3() TestUtils.AreEqual(bool3(true, false, false), isfinite(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_float4() { TestUtils.AreEqual(bool4(false, false, true, true), isfinite(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f))); @@ -151,7 +151,7 @@ public static void isfinite_float4() TestUtils.AreEqual(bool4(false, false, false, false), isfinite(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_double() { TestUtils.AreEqual(false, isfinite(TestUtils.SignedDoubleQNaN())); @@ -165,7 +165,7 @@ public static void isfinite_double() TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_double2() { TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity))); @@ -175,7 +175,7 @@ public static void isfinite_double2() TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_double3() { TestUtils.AreEqual(bool3(false, false, true), isfinite(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue))); @@ -183,7 +183,7 @@ public static void isfinite_double3() TestUtils.AreEqual(bool3(true, false, false), isfinite(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isfinite_double4() { TestUtils.AreEqual(bool4(false, false, true, true), isfinite(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0))); @@ -191,7 +191,7 @@ public static void isfinite_double4() TestUtils.AreEqual(bool4(false, false, false, false), isfinite(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_float() { TestUtils.AreEqual(false, isinf(TestUtils.SignedFloatQNaN())); @@ -205,7 +205,7 @@ public static void isinf_float() TestUtils.AreEqual(false, isinf(TestUtils.UnsignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_float2() { TestUtils.AreEqual(bool2(false, true), isinf(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity))); @@ -215,7 +215,7 @@ public static void isinf_float2() TestUtils.AreEqual(bool2(false, false), isinf(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_float3() { TestUtils.AreEqual(bool3(false, true, false), isinf(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue))); @@ -223,7 +223,7 @@ public static void isinf_float3() TestUtils.AreEqual(bool3(false, true, false), isinf(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_float4() { TestUtils.AreEqual(bool4(false, true, false, false), isinf(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f))); @@ -231,7 +231,7 @@ public static void isinf_float4() TestUtils.AreEqual(bool4(false, false, false, false), isinf(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_double() { TestUtils.AreEqual(false, isinf(TestUtils.SignedDoubleQNaN())); @@ -245,7 +245,7 @@ public static void isinf_double() TestUtils.AreEqual(false, isinf(TestUtils.UnsignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_double2() { TestUtils.AreEqual(bool2(false, true), isinf(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity))); @@ -255,7 +255,7 @@ public static void isinf_double2() TestUtils.AreEqual(bool2(false, false), isinf(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_double3() { TestUtils.AreEqual(bool3(false, true, false), isinf(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue))); @@ -263,7 +263,7 @@ public static void isinf_double3() TestUtils.AreEqual(bool3(false, true, false), isinf(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isinf_double4() { TestUtils.AreEqual(bool4(false, true, false, false), isinf(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0))); @@ -271,7 +271,7 @@ public static void isinf_double4() TestUtils.AreEqual(bool4(false, false, false, false), isinf(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_float() { TestUtils.AreEqual(true, isnan(TestUtils.SignedFloatQNaN())); @@ -285,7 +285,7 @@ public static void isnan_float() TestUtils.AreEqual(true, isnan(TestUtils.UnsignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_float2() { TestUtils.AreEqual(bool2(true, false), isnan(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity))); @@ -295,7 +295,7 @@ public static void isnan_float2() TestUtils.AreEqual(bool2(true, true), isnan(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_float3() { TestUtils.AreEqual(bool3(true, false, false), isnan(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue))); @@ -303,7 +303,7 @@ public static void isnan_float3() TestUtils.AreEqual(bool3(false, false, true), isnan(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_float4() { TestUtils.AreEqual(bool4(true, false, false, false), isnan(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f))); @@ -311,7 +311,7 @@ public static void isnan_float4() TestUtils.AreEqual(bool4(true, true, true, true), isnan(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_double() { TestUtils.AreEqual(true, isnan(TestUtils.SignedDoubleQNaN())); @@ -325,7 +325,7 @@ public static void isnan_double() TestUtils.AreEqual(true, isnan(TestUtils.UnsignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_double2() { TestUtils.AreEqual(bool2(true, false), isnan(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity))); @@ -335,7 +335,7 @@ public static void isnan_double2() TestUtils.AreEqual(bool2(true, true), isnan(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_double3() { TestUtils.AreEqual(bool3(true, false, false), isnan(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue))); @@ -343,7 +343,7 @@ public static void isnan_double3() TestUtils.AreEqual(bool3(false, false, true), isnan(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void isnan_double4() { TestUtils.AreEqual(bool4(true, false, false, false), isnan(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0))); @@ -351,7 +351,7 @@ public static void isnan_double4() TestUtils.AreEqual(bool4(true, true, true, true), isnan(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_float() { TestUtils.AreEqual(0.3499935f, sin(-1000000f), 1, false); @@ -364,7 +364,7 @@ public static void sin_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sin(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_float2() { TestUtils.AreEqual(float2(0.3499935f, -0.9320391f), sin(float2(-1000000f, -1.2f)), 1, false); @@ -373,7 +373,7 @@ public static void sin_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_float3() { TestUtils.AreEqual(float3(0.3499935f, -0.9320391f, 0f), sin(float3(-1000000f, -1.2f, 0f)), 1, false); @@ -381,14 +381,14 @@ public static void sin_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_float4() { TestUtils.AreEqual(float4(0.3499935f, -0.9320391f, 0f, 0.9320391f), sin(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(-0.3499935f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_double() { TestUtils.AreEqual(0.34999350217129294, sin(-1000000.0), 32, false); @@ -401,7 +401,7 @@ public static void sin_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sin(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_double2() { TestUtils.AreEqual(double2(0.34999350217129294, -0.9320390859672264), sin(double2(-1000000.0, -1.2)), 32, false); @@ -410,7 +410,7 @@ public static void sin_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_double3() { TestUtils.AreEqual(double3(0.34999350217129294, -0.9320390859672264, 0.0), sin(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -418,14 +418,14 @@ public static void sin_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sin_double4() { TestUtils.AreEqual(double4(0.34999350217129294, -0.9320390859672264, 0.0, 0.9320390859672264), sin(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(-0.34999350217129294, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_float() { TestUtils.AreEqual(0.936752141f, cos(-1000000f), 8, false); @@ -438,7 +438,7 @@ public static void cos_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), cos(float.PositiveInfinity), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_float2() { TestUtils.AreEqual(float2(0.936752141f, 0.362357765f), cos(float2(-1000000f, -1.2f)), 8, false); @@ -447,7 +447,7 @@ public static void cos_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_float3() { TestUtils.AreEqual(float3(0.936752141f, 0.362357765f, 1f), cos(float3(-1000000f, -1.2f, 0f)), 8, false); @@ -455,14 +455,14 @@ public static void cos_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_float4() { TestUtils.AreEqual(float4(0.936752141f, 0.362357765f, 1f, 0.362357765f), cos(float4(-1000000f, -1.2f, 0f, 1.2f)), 8, false); TestUtils.AreEqual(float4(0.936752141f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_double() { TestUtils.AreEqual(0.93675212753314474, cos(-1000000.0), 32, false); @@ -475,7 +475,7 @@ public static void cos_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), cos(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_double2() { TestUtils.AreEqual(double2(0.93675212753314474, 0.36235775447667357), cos(double2(-1000000.0, -1.2)), 32, false); @@ -484,7 +484,7 @@ public static void cos_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_double3() { TestUtils.AreEqual(double3(0.93675212753314474, 0.36235775447667357, 1.0), cos(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -492,14 +492,14 @@ public static void cos_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cos_double4() { TestUtils.AreEqual(double4(0.93675212753314474, 0.36235775447667357, 1.0, 0.36235775447667357), cos(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.93675212753314474, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_float() { TestUtils.AreEqual(0.373624444f, tan(-1000000f), 1, false); @@ -512,7 +512,7 @@ public static void tan_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), tan(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_float2() { TestUtils.AreEqual(float2(0.373624444f, -2.57215166f), tan(float2(-1000000f, -1.2f)), 1, false); @@ -521,7 +521,7 @@ public static void tan_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_float3() { TestUtils.AreEqual(float3(0.373624444f, -2.57215166f, 0f), tan(float3(-1000000f, -1.2f, 0f)), 1, false); @@ -529,14 +529,14 @@ public static void tan_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_float4() { TestUtils.AreEqual(float4(0.373624444f, -2.57215166f, 0f, 2.57215166f), tan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(-0.373624444f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_double() { TestUtils.AreEqual(0.373624453987599, tan(-1000000.0), 32, false); @@ -549,7 +549,7 @@ public static void tan_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), tan(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_double2() { TestUtils.AreEqual(double2(0.373624453987599, -2.57215162212632), tan(double2(-1000000.0, -1.2)), 32, false); @@ -558,7 +558,7 @@ public static void tan_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_double3() { TestUtils.AreEqual(double3(0.373624453987599, -2.57215162212632, 0.0), tan(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -566,14 +566,14 @@ public static void tan_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tan_double4() { TestUtils.AreEqual(double4(0.373624453987599, -2.57215162212632, 0.0, 2.57215162212632), tan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(-0.373624453987599, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_float() { TestUtils.AreEqual(-1.5707953f, atan(-1000000f), 1, false); @@ -586,7 +586,7 @@ public static void atan_float() TestUtils.AreEqual(1.57079637f, atan(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_float2() { TestUtils.AreEqual(float2(-1.5707953f, -0.876058042f), atan(float2(-1000000f, -1.2f)), 1, false); @@ -595,7 +595,7 @@ public static void atan_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_float3() { TestUtils.AreEqual(float3(-1.5707953f, -0.876058042f, 0f), atan(float3(-1000000f, -1.2f, 0f)), 1, false); @@ -603,14 +603,14 @@ public static void atan_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1.57079637f, 1.57079637f), atan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_float4() { TestUtils.AreEqual(float4(-1.5707953f, -0.876058042f, 0f, 0.876058042f), atan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(1.5707953f, -1.57079637f, TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_double() { TestUtils.AreEqual(-1.5707953267948971, atan(-1000000.0), 32, false); @@ -623,7 +623,7 @@ public static void atan_double() TestUtils.AreEqual(1.570796326794897, atan(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_double2() { TestUtils.AreEqual(double2(-1.5707953267948971, -0.87605805059819342), atan(double2(-1000000.0, -1.2)), 32, false); @@ -632,7 +632,7 @@ public static void atan_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_double3() { TestUtils.AreEqual(double3(-1.5707953267948971, -0.87605805059819342, 0.0), atan(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -640,14 +640,14 @@ public static void atan_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.570796326794897, 1.570796326794897), atan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan_double4() { TestUtils.AreEqual(double4(-1.5707953267948971, -0.87605805059819342, 0.0, 0.87605805059819342), atan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(1.5707953267948971, -1.570796326794897, TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_float() { TestUtils.AreEqual(0.9119903f, atan2(3.1f, 2.4f), 1, false); @@ -664,7 +664,7 @@ public static void atan2_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), atan2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_float2() { TestUtils.AreEqual(float2(0.9119903f, 2.22960234f), atan2(float2(3.1f, 3.1f), float2(2.4f, -2.4f)), 1, false); @@ -675,7 +675,7 @@ public static void atan2_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(1f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_float3() { TestUtils.AreEqual(float3(0.9119903f, 2.22960234f, -0.9119903f), atan2(float3(3.1f, 3.1f, -3.1f), float3(2.4f, -2.4f, 2.4f)), 1, false); @@ -684,7 +684,7 @@ public static void atan2_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float3(1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_float4() { TestUtils.AreEqual(float4(0.9119903f, 2.22960234f, -0.9119903f, -2.22960234f), atan2(float4(3.1f, 3.1f, -3.1f, -3.1f), float4(2.4f, -2.4f, 2.4f, -2.4f)), 1, false); @@ -692,7 +692,7 @@ public static void atan2_float4() TestUtils.AreEqual(float4(1.57079637f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float4(float.PositiveInfinity, 1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(1f, TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_double() { TestUtils.AreEqual(0.91199029067742043, atan2(3.1, 2.4), 32, false); @@ -709,7 +709,7 @@ public static void atan2_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), atan2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_double2() { TestUtils.AreEqual(double2(0.91199029067742043, 2.2296023629123729), atan2(double2(3.1, 3.1), double2(2.4, -2.4)), 32, false); @@ -720,7 +720,7 @@ public static void atan2_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(1.0, TestUtils.SignedDoubleQNaN())), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_double3() { TestUtils.AreEqual(double3(0.91199029067742043, 2.2296023629123729, -0.91199029067742043), atan2(double3(3.1, 3.1, -3.1), double3(2.4, -2.4, 2.4)), 32, false); @@ -729,7 +729,7 @@ public static void atan2_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double3(1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void atan2_double4() { TestUtils.AreEqual(double4(0.91199029067742043, 2.2296023629123729, -0.91199029067742043, -2.2296023629123729), atan2(double4(3.1, 3.1, -3.1, -3.1), double4(2.4, -2.4, 2.4, -2.4)), 32, false); @@ -737,7 +737,7 @@ public static void atan2_double4() TestUtils.AreEqual(double4(1.5707963267948966, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double4(double.PositiveInfinity, 1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(1.0, TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_float() { TestUtils.AreEqual(-3.62686038f, sinh(-2f), 1, false); @@ -750,7 +750,7 @@ public static void sinh_float() TestUtils.AreEqual(float.PositiveInfinity, sinh(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_float2() { TestUtils.AreEqual(float2(-3.62686038f, -1.5094614f), sinh(float2(-2f, -1.2f)), 1, false); @@ -759,7 +759,7 @@ public static void sinh_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_float3() { TestUtils.AreEqual(float3(-3.62686038f, -1.5094614f, 0f), sinh(float3(-2f, -1.2f, 0f)), 1, false); @@ -767,14 +767,14 @@ public static void sinh_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sinh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_float4() { TestUtils.AreEqual(float4(-3.62686038f, -1.5094614f, 0f, 1.5094614f), sinh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(3.62686038f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_double() { TestUtils.AreEqual(-3.6268604078470181, sinh(-2.0), 32, false); @@ -787,7 +787,7 @@ public static void sinh_double() TestUtils.AreEqual(double.PositiveInfinity, sinh(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_double2() { TestUtils.AreEqual(double2(-3.6268604078470181, -1.509461355412173), sinh(double2(-2.0, -1.2)), 32, false); @@ -796,7 +796,7 @@ public static void sinh_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_double3() { TestUtils.AreEqual(double3(-3.6268604078470181, -1.509461355412173, 0.0), sinh(double3(-2.0, -1.2, 0.0)), 32, false); @@ -804,14 +804,14 @@ public static void sinh_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sinh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sinh_double4() { TestUtils.AreEqual(double4(-3.6268604078470181, -1.509461355412173, 0.0, 1.509461355412173), sinh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(3.6268604078470181, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_float() { TestUtils.AreEqual(3.76219559f, cosh(-2f), 1, false); @@ -824,7 +824,7 @@ public static void cosh_float() TestUtils.AreEqual(float.PositiveInfinity, cosh(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_float2() { TestUtils.AreEqual(float2(3.76219559f, 1.81065559f), cosh(float2(-2f, -1.2f)), 1, false); @@ -833,7 +833,7 @@ public static void cosh_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_float3() { TestUtils.AreEqual(float3(3.76219559f, 1.81065559f, 1f), cosh(float3(-2f, -1.2f, 0f)), 1, false); @@ -841,14 +841,14 @@ public static void cosh_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), cosh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_float4() { TestUtils.AreEqual(float4(3.76219559f, 1.81065559f, 1f, 1.81065559f), cosh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(3.76219559f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_double() { TestUtils.AreEqual(3.7621956910836314, cosh(-2.0), 32, false); @@ -861,7 +861,7 @@ public static void cosh_double() TestUtils.AreEqual(double.PositiveInfinity, cosh(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_double2() { TestUtils.AreEqual(double2(3.7621956910836314, 1.81065556732437), cosh(double2(-2.0, -1.2)), 32, false); @@ -870,7 +870,7 @@ public static void cosh_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_double3() { TestUtils.AreEqual(double3(3.7621956910836314, 1.81065556732437, 1.0), cosh(double3(-2.0, -1.2, 0.0)), 32, false); @@ -878,14 +878,14 @@ public static void cosh_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), cosh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void cosh_double4() { TestUtils.AreEqual(double4(3.7621956910836314, 1.81065556732437, 1.0, 1.81065556732437), cosh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(3.7621956910836314, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_float() { TestUtils.AreEqual(-0.9640276f, tanh(-2f), 1, false); @@ -898,7 +898,7 @@ public static void tanh_float() TestUtils.AreEqual(1f, tanh(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_float2() { TestUtils.AreEqual(float2(-0.9640276f, -0.8336546f), tanh(float2(-2f, -1.2f)), 1, false); @@ -907,7 +907,7 @@ public static void tanh_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1f), tanh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_float3() { TestUtils.AreEqual(float3(-0.9640276f, -0.8336546f, 0f), tanh(float3(-2f, -1.2f, 0f)), 1, false); @@ -915,14 +915,14 @@ public static void tanh_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1f, 1f), tanh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_float4() { TestUtils.AreEqual(float4(-0.9640276f, -0.8336546f, 0f, 0.8336546f), tanh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(0.9640276f, -1f, TestUtils.SignedFloatQNaN(), 1f), tanh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_double() { TestUtils.AreEqual(-0.9640275800758169, tanh(-2.0), 32, false); @@ -935,7 +935,7 @@ public static void tanh_double() TestUtils.AreEqual(1.0, tanh(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_double2() { TestUtils.AreEqual(double2(-0.9640275800758169, -0.83365460701215521), tanh(double2(-2.0, -1.2)), 32, false); @@ -944,7 +944,7 @@ public static void tanh_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.0), tanh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_double3() { TestUtils.AreEqual(double3(-0.9640275800758169, -0.83365460701215521, 0.0), tanh(double3(-2.0, -1.2, 0.0)), 32, false); @@ -952,14 +952,14 @@ public static void tanh_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.0, 1.0), tanh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void tanh_double4() { TestUtils.AreEqual(double4(-0.9640275800758169, -0.83365460701215521, 0.0, 0.83365460701215521), tanh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.9640275800758169, -1.0, TestUtils.SignedDoubleQNaN(), 1.0), tanh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_float() { TestUtils.AreEqual(4.539993E-05f, exp(-10f), 1, false); @@ -971,7 +971,7 @@ public static void exp_float() TestUtils.AreEqual(float.PositiveInfinity, exp(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_float2() { TestUtils.AreEqual(float2(4.539993E-05f, 0.301194221f), exp(float2(-10f, -1.2f)), 1, false); @@ -980,7 +980,7 @@ public static void exp_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_float3() { TestUtils.AreEqual(float3(4.539993E-05f, 0.301194221f, 1f), exp(float3(-10f, -1.2f, 0f)), 1, false); @@ -988,14 +988,14 @@ public static void exp_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_float4() { TestUtils.AreEqual(float4(4.539993E-05f, 0.301194221f, 1f, 3.320117f), exp(float4(-10f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_double() { TestUtils.AreEqual(4.5399929762484847E-05, exp(-10.0), 32, false); @@ -1007,7 +1007,7 @@ public static void exp_double() TestUtils.AreEqual(double.PositiveInfinity, exp(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_double2() { TestUtils.AreEqual(double2(4.5399929762484847E-05, 0.30119421191220208), exp(double2(-10.0, -1.2)), 32, false); @@ -1016,7 +1016,7 @@ public static void exp_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_double3() { TestUtils.AreEqual(double3(4.5399929762484847E-05, 0.30119421191220208, 1.0), exp(double3(-10.0, -1.2, 0.0)), 32, false); @@ -1024,14 +1024,14 @@ public static void exp_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp_double4() { TestUtils.AreEqual(double4(4.5399929762484847E-05, 0.30119421191220208, 1.0, 3.3201169227365477), exp(double4(-10.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_float() { TestUtils.AreEqual(0.0009765625f, exp2(-10f), 1, false); @@ -1043,7 +1043,7 @@ public static void exp2_float() TestUtils.AreEqual(float.PositiveInfinity, exp2(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_float2() { TestUtils.AreEqual(float2(0.0009765625f, 0.4352753f), exp2(float2(-10f, -1.2f)), 1, false); @@ -1052,7 +1052,7 @@ public static void exp2_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_float3() { TestUtils.AreEqual(float3(0.0009765625f, 0.4352753f, 1f), exp2(float3(-10f, -1.2f, 0f)), 1, false); @@ -1060,14 +1060,14 @@ public static void exp2_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_float4() { TestUtils.AreEqual(float4(0.0009765625f, 0.4352753f, 1f, 2.29739666f), exp2(float4(-10f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_double() { TestUtils.AreEqual(0.0009765625, exp2(-10.0), 32, false); @@ -1079,7 +1079,7 @@ public static void exp2_double() TestUtils.AreEqual(double.PositiveInfinity, exp2(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_double2() { TestUtils.AreEqual(double2(0.0009765625, 0.435275281648062), exp2(double2(-10.0, -1.2)), 32, false); @@ -1088,7 +1088,7 @@ public static void exp2_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_double3() { TestUtils.AreEqual(double3(0.0009765625, 0.435275281648062, 1.0), exp2(double3(-10.0, -1.2, 0.0)), 32, false); @@ -1096,14 +1096,14 @@ public static void exp2_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp2_double4() { TestUtils.AreEqual(double4(0.0009765625, 0.435275281648062, 1.0, 2.29739670999407), exp2(double4(-10.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_float() { TestUtils.AreEqual(1E-10f, exp10(-10f), 32, false); @@ -1115,7 +1115,7 @@ public static void exp10_float() TestUtils.AreEqual(float.PositiveInfinity, exp10(float.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_float2() { TestUtils.AreEqual(float2(1E-10f, 0.06309573f), exp10(float2(-10f, -1.2f)), 32, false); @@ -1124,7 +1124,7 @@ public static void exp10_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp10(float2(float.PositiveInfinity, float.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_float3() { TestUtils.AreEqual(float3(1E-10f, 0.06309573f, 1f), exp10(float3(-10f, -1.2f, 0f)), 32, false); @@ -1132,14 +1132,14 @@ public static void exp10_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_float4() { TestUtils.AreEqual(float4(1E-10f, 0.06309573f, 1f, 15.8489323f), exp10(float4(-10f, -1.2f, 0f, 1.2f)), 32, false); TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_double() { TestUtils.AreEqual(1E-10, exp10(-10.0), 32, false); @@ -1151,7 +1151,7 @@ public static void exp10_double() TestUtils.AreEqual(double.PositiveInfinity, exp10(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_double2() { TestUtils.AreEqual(double2(1E-10, 0.063095734448019331), exp10(double2(-10.0, -1.2)), 32, false); @@ -1160,7 +1160,7 @@ public static void exp10_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_double3() { TestUtils.AreEqual(double3(1E-10, 0.063095734448019331, 1.0), exp10(double3(-10.0, -1.2, 0.0)), 32, false); @@ -1168,14 +1168,14 @@ public static void exp10_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void exp10_double4() { TestUtils.AreEqual(double4(1E-10, 0.063095734448019331, 1.0, 15.848931924611135), exp10(double4(-10.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_float() { TestUtils.AreEqual(-20.5409451f, log(1.2E-09f), 1, false); @@ -1187,7 +1187,7 @@ public static void log_float() TestUtils.AreEqual(float.PositiveInfinity, log(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_float2() { TestUtils.AreEqual(float2(-20.5409451f, 0f), log(float2(1.2E-09f, 1f)), 1, false); @@ -1196,7 +1196,7 @@ public static void log_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_float3() { TestUtils.AreEqual(float3(-20.5409451f, 0f, 23.2081718f), log(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false); @@ -1204,14 +1204,14 @@ public static void log_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_float4() { TestUtils.AreEqual(float4(-20.5409451f, 0f, 23.2081718f, TestUtils.SignedFloatQNaN()), log(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_double() { TestUtils.AreEqual(-20.540944280152456, log(1.2E-09), 32, false); @@ -1223,7 +1223,7 @@ public static void log_double() TestUtils.AreEqual(double.PositiveInfinity, log(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_double2() { TestUtils.AreEqual(double2(-20.540944280152456, 0.0), log(double2(1.2E-09, 1.0)), 32, false); @@ -1232,7 +1232,7 @@ public static void log_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_double3() { TestUtils.AreEqual(double3(-20.540944280152456, 0.0, 23.208172486734409), log(double3(1.2E-09, 1.0, 12000000000.0)), 32, false); @@ -1240,14 +1240,14 @@ public static void log_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log_double4() { TestUtils.AreEqual(double4(-20.540944280152456, 0.0, 23.208172486734409, TestUtils.SignedDoubleQNaN()), log(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_float() { TestUtils.AreEqual(-29.63432f, log2(1.2E-09f), 1, false); @@ -1259,7 +1259,7 @@ public static void log2_float() TestUtils.AreEqual(float.PositiveInfinity, log2(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_float2() { TestUtils.AreEqual(float2(-29.63432f, 0f), log2(float2(1.2E-09f, 1f)), 1, false); @@ -1268,7 +1268,7 @@ public static void log2_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_float3() { TestUtils.AreEqual(float3(-29.63432f, 0f, 33.4823151f), log2(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false); @@ -1276,14 +1276,14 @@ public static void log2_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_float4() { TestUtils.AreEqual(float4(-29.63432f, 0f, 33.4823151f, TestUtils.SignedFloatQNaN()), log2(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_double() { TestUtils.AreEqual(-29.634318448152467, log2(1.2E-09), 32, false); @@ -1295,7 +1295,7 @@ public static void log2_double() TestUtils.AreEqual(double.PositiveInfinity, log2(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_double2() { TestUtils.AreEqual(double2(-29.634318448152467, 0.0), log2(double2(1.2E-09, 1.0)), 32, false); @@ -1304,7 +1304,7 @@ public static void log2_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_double3() { TestUtils.AreEqual(double3(-29.634318448152467, 0.0, 33.482315354707417), log2(double3(1.2E-09, 1.0, 12000000000.0)), 32, false); @@ -1312,14 +1312,14 @@ public static void log2_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log2_double4() { TestUtils.AreEqual(double4(-29.634318448152467, 0.0, 33.482315354707417, TestUtils.SignedDoubleQNaN()), log2(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_float() { TestUtils.AreEqual(-8.920818f, log10(1.2E-09f), 1, false); @@ -1331,7 +1331,7 @@ public static void log10_float() TestUtils.AreEqual(float.PositiveInfinity, log10(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_float2() { TestUtils.AreEqual(float2(-8.920818f, 0f), log10(float2(1.2E-09f, 1f)), 1, false); @@ -1340,7 +1340,7 @@ public static void log10_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log10(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_float3() { TestUtils.AreEqual(float3(-8.920818f, 0f, 10.0791817f), log10(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false); @@ -1348,14 +1348,14 @@ public static void log10_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_float4() { TestUtils.AreEqual(float4(-8.920818f, 0f, 10.0791817f, TestUtils.SignedFloatQNaN()), log10(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_double() { TestUtils.AreEqual(-8.9208187539523749, log10(1.2E-09), 32, false); @@ -1367,7 +1367,7 @@ public static void log10_double() TestUtils.AreEqual(double.PositiveInfinity, log10(double.PositiveInfinity), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_double2() { TestUtils.AreEqual(double2(-8.9208187539523749, 0.0), log10(double2(1.2E-09, 1.0)), 32, false); @@ -1376,7 +1376,7 @@ public static void log10_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_double3() { TestUtils.AreEqual(double3(-8.9208187539523749, 0.0, 10.079181246047623), log10(double3(1.2E-09, 1.0, 12000000000.0)), 32, false); @@ -1384,14 +1384,14 @@ public static void log10_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void log10_double4() { TestUtils.AreEqual(double4(-8.9208187539523749, 0.0, 10.079181246047623, TestUtils.SignedDoubleQNaN()), log10(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_float() { TestUtils.AreEqual(-2.154609f, radians(-123.45f), 1, false); @@ -1402,7 +1402,7 @@ public static void radians_float() TestUtils.AreEqual(float.PositiveInfinity, radians(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_float2() { TestUtils.AreEqual(float2(-2.154609f, 0f), radians(float2(-123.45f, 0f)), 1, false); @@ -1410,21 +1410,21 @@ public static void radians_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_float3() { TestUtils.AreEqual(float3(-2.154609f, 0f, 2.154609f), radians(float3(-123.45f, 0f, 123.45f)), 1, false); TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_float4() { TestUtils.AreEqual(float4(-2.154609f, 0f, 2.154609f, float.NegativeInfinity), radians(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), radians(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_double() { TestUtils.AreEqual(-2.154608961587, radians(-123.45), 1, false); @@ -1435,7 +1435,7 @@ public static void radians_double() TestUtils.AreEqual(double.PositiveInfinity, radians(double.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_double2() { TestUtils.AreEqual(double2(-2.154608961587, 0.0), radians(double2(-123.45, 0.0)), 1, false); @@ -1443,21 +1443,21 @@ public static void radians_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_double3() { TestUtils.AreEqual(double3(-2.154608961587, 0.0, 2.154608961587), radians(double3(-123.45, 0.0, 123.45)), 1, false); TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void radians_double4() { TestUtils.AreEqual(double4(-2.154608961587, 0.0, 2.154608961587, double.NegativeInfinity), radians(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), radians(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_float() { TestUtils.AreEqual(-7073.164f, degrees(-123.45f), 1, false); @@ -1468,7 +1468,7 @@ public static void degrees_float() TestUtils.AreEqual(float.PositiveInfinity, degrees(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_float2() { TestUtils.AreEqual(float2(-7073.164f, 0f), degrees(float2(-123.45f, 0f)), 1, false); @@ -1476,21 +1476,21 @@ public static void degrees_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_float3() { TestUtils.AreEqual(float3(-7073.164f, 0f, 7073.164f), degrees(float3(-123.45f, 0f, 123.45f)), 1, false); TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_float4() { TestUtils.AreEqual(float4(-7073.164f, 0f, 7073.164f, float.NegativeInfinity), degrees(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), degrees(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_double() { TestUtils.AreEqual(-7073.1639808900127, degrees(-123.45), 1, false); @@ -1501,7 +1501,7 @@ public static void degrees_double() TestUtils.AreEqual(double.PositiveInfinity, degrees(double.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_double2() { TestUtils.AreEqual(double2(-7073.1639808900127, 0.0), degrees(double2(-123.45, 0.0)), 1, false); @@ -1509,21 +1509,21 @@ public static void degrees_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_double3() { TestUtils.AreEqual(double3(-7073.1639808900127, 0.0, 7073.1639808900127), degrees(double3(-123.45, 0.0, 123.45)), 1, false); TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void degrees_double4() { TestUtils.AreEqual(double4(-7073.1639808900127, 0.0, 7073.1639808900127, double.NegativeInfinity), degrees(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), degrees(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_int() { TestUtils.AreEqual(-1, sign(-156)); @@ -1540,7 +1540,7 @@ public static void sign_int() TestUtils.AreEqual(-1, sign(-2147483648)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_int2() { TestUtils.AreEqual(int2(-1, -1), sign(int2(-156, -214748346))); @@ -1551,7 +1551,7 @@ public static void sign_int2() TestUtils.AreEqual(int2(1, -1), sign(int2(2147483647, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_int3() { TestUtils.AreEqual(int3(-1, -1, 0), sign(int3(-156, -214748346, 0))); @@ -1560,7 +1560,7 @@ public static void sign_int3() TestUtils.AreEqual(int3(1, 1, -1), sign(int3(64583, 2147483647, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_int4() { TestUtils.AreEqual(int4(-1, -1, 0, 1), sign(int4(-156, -214748346, 0, 214748346))); @@ -1568,7 +1568,7 @@ public static void sign_int4() TestUtils.AreEqual(int4(-1, 1, 1, -1), sign(int4(-15379, 64583, 2147483647, -2147483648))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_float() { TestUtils.AreEqual(-1f, sign(-123.45f)); @@ -1581,7 +1581,7 @@ public static void sign_float() TestUtils.AreEqual(1f, sign(float.PositiveInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_float2() { TestUtils.AreEqual(float2(-1f, -1f), sign(float2(-123.45f, -1E-20f))); @@ -1590,7 +1590,7 @@ public static void sign_float2() TestUtils.AreEqual(float2(0f, 1f), sign(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_float3() { TestUtils.AreEqual(float3(-1f, -1f, 0f), sign(float3(-123.45f, -1E-20f, 0f))); @@ -1598,14 +1598,14 @@ public static void sign_float3() TestUtils.AreEqual(float3(0f, 1f, 1f), sign(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_float4() { TestUtils.AreEqual(float4(-1f, -1f, 0f, 1f), sign(float4(-123.45f, -1E-20f, 0f, 1E-10f))); TestUtils.AreEqual(float4(1f, -1f, 0f, 1f), sign(float4(123.45f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_double() { TestUtils.AreEqual(-1.0, sign(-123.45)); @@ -1618,7 +1618,7 @@ public static void sign_double() TestUtils.AreEqual(1.0, sign(double.PositiveInfinity)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_double2() { TestUtils.AreEqual(double2(-1.0, -1.0), sign(double2(-123.45, -1E-20))); @@ -1627,7 +1627,7 @@ public static void sign_double2() TestUtils.AreEqual(double2(0.0, 1.0), sign(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_double3() { TestUtils.AreEqual(double3(-1.0, -1.0, 0.0), sign(double3(-123.45, -1E-20, 0.0))); @@ -1635,14 +1635,14 @@ public static void sign_double3() TestUtils.AreEqual(double3(0.0, 1.0, 1.0), sign(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sign_double4() { TestUtils.AreEqual(double4(-1.0, -1.0, 0.0, 1.0), sign(double4(-123.45, -1E-20, 0.0, 1E-10))); TestUtils.AreEqual(double4(1.0, -1.0, 0.0, 1.0), sign(double4(123.45, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sqrt(-1f), 1, false); @@ -1654,7 +1654,7 @@ public static void sqrt_float() TestUtils.AreEqual(float.PositiveInfinity, sqrt(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), sqrt(float2(-1f, 0f)), 1, false); @@ -1663,7 +1663,7 @@ public static void sqrt_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), sqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 1E-05f), sqrt(float3(-1f, 0f, 1E-10f)), 1, false); @@ -1671,14 +1671,14 @@ public static void sqrt_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), sqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 1E-05f, 11.1108055f), sqrt(float4(-1f, 0f, 1E-10f, 123.45f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sqrt(-1.0), 1, false); @@ -1690,7 +1690,7 @@ public static void sqrt_double() TestUtils.AreEqual(double.PositiveInfinity, sqrt(double.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), sqrt(double2(-1.0, 0.0)), 1, false); @@ -1699,7 +1699,7 @@ public static void sqrt_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), sqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05), sqrt(double3(-1.0, 0.0, 1E-10)), 1, false); @@ -1707,14 +1707,14 @@ public static void sqrt_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), sqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void sqrt_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05, 11.11080555135405), sqrt(double4(-1.0, 0.0, 1E-10, 123.45)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), rsqrt(-1f), 1, false); @@ -1726,7 +1726,7 @@ public static void rsqrt_float() TestUtils.AreEqual(0f, rsqrt(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), rsqrt(float2(-1f, 0f)), 1, false); @@ -1735,7 +1735,7 @@ public static void rsqrt_float2() TestUtils.AreEqual(float2(0f, 0f), rsqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f), rsqrt(float3(-1f, 0f, 1E+10f)), 1, false); @@ -1743,14 +1743,14 @@ public static void rsqrt_float3() TestUtils.AreEqual(float3(0f, 0f, 0f), rsqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f, 0.09000248f), rsqrt(float4(-1f, 0f, 1E+10f, 123.45f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), 0f, 0f), rsqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), rsqrt(-1.0), 1, false); @@ -1762,7 +1762,7 @@ public static void rsqrt_double() TestUtils.AreEqual(0.0, rsqrt(double.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), rsqrt(double2(-1.0, 0.0)), 1, false); @@ -1771,7 +1771,7 @@ public static void rsqrt_double2() TestUtils.AreEqual(double2(0.0, 0.0), rsqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05), rsqrt(double3(-1.0, 0.0, 10000000000.0)), 1, false); @@ -1779,14 +1779,14 @@ public static void rsqrt_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), rsqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rsqrt_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05, 0.090002475102098425), rsqrt(double4(-1.0, 0.0, 10000000000.0, 123.45)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rsqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_float() { TestUtils.AreEqual(-0.008100445f, rcp(-123.45f), 1, false); @@ -1796,7 +1796,7 @@ public static void rcp_float() TestUtils.AreEqual(0f, rcp(float.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_float2() { TestUtils.AreEqual(float2(-0.008100445f, float.PositiveInfinity), rcp(float2(-123.45f, 0f)), 1, false); @@ -1804,21 +1804,21 @@ public static void rcp_float2() TestUtils.AreEqual(float2(0f, 0f), rcp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_float3() { TestUtils.AreEqual(float3(-0.008100445f, float.PositiveInfinity, 0.008100445f), rcp(float3(-123.45f, 0f, 123.45f)), 1, false); TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0f), rcp(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_float4() { TestUtils.AreEqual(float4(-0.008100445f, float.PositiveInfinity, 0.008100445f, TestUtils.SignedFloatQNaN()), rcp(float4(-123.45f, 0f, 123.45f, TestUtils.SignedFloatQNaN())), 1, false); TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), rcp(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_double() { TestUtils.AreEqual(-0.0081004455245038479, rcp(-123.45), 1, false); @@ -1828,7 +1828,7 @@ public static void rcp_double() TestUtils.AreEqual(0.0, rcp(double.PositiveInfinity), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_double2() { TestUtils.AreEqual(double2(-0.0081004455245038479, double.PositiveInfinity), rcp(double2(-123.45, 0.0)), 1, false); @@ -1836,21 +1836,21 @@ public static void rcp_double2() TestUtils.AreEqual(double2(0.0, 0.0), rcp(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_double3() { TestUtils.AreEqual(double3(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479), rcp(double3(-123.45, 0.0, 123.45)), 1, false); TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rcp(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rcp_double4() { TestUtils.AreEqual(double4(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479, TestUtils.SignedDoubleQNaN()), rcp(double4(-123.45, 0.0, 123.45, TestUtils.SignedDoubleQNaN())), 1, false); TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), rcp(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_float() { TestUtils.AreEqual(float.NegativeInfinity, floor(float.NegativeInfinity)); @@ -1865,7 +1865,7 @@ public static void floor_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), floor(TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), floor(float2(float.NegativeInfinity, -100.51f))); @@ -1875,7 +1875,7 @@ public static void floor_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), floor(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -101f), floor(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -1884,7 +1884,7 @@ public static void floor_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -101f, -101f), floor(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -1892,7 +1892,7 @@ public static void floor_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_double() { TestUtils.AreEqual(double.NegativeInfinity, floor(double.NegativeInfinity)); @@ -1907,7 +1907,7 @@ public static void floor_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), floor(TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), floor(double2(double.NegativeInfinity, -100.51))); @@ -1917,7 +1917,7 @@ public static void floor_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), floor(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -101.0), floor(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -1926,7 +1926,7 @@ public static void floor_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floor_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -101.0, -101.0), floor(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -1934,7 +1934,7 @@ public static void floor_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_float() { TestUtils.AreEqual(float.NegativeInfinity, ceil(float.NegativeInfinity)); @@ -1949,7 +1949,7 @@ public static void ceil_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), ceil(TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), ceil(float2(float.NegativeInfinity, -100.51f))); @@ -1959,7 +1959,7 @@ public static void ceil_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), ceil(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), ceil(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -1968,7 +1968,7 @@ public static void ceil_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), ceil(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -1976,7 +1976,7 @@ public static void ceil_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_double() { TestUtils.AreEqual(double.NegativeInfinity, ceil(double.NegativeInfinity)); @@ -1991,7 +1991,7 @@ public static void ceil_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), ceil(TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), ceil(double2(double.NegativeInfinity, -100.51))); @@ -2001,7 +2001,7 @@ public static void ceil_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), ceil(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), ceil(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -2010,7 +2010,7 @@ public static void ceil_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceil_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), ceil(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -2018,7 +2018,7 @@ public static void ceil_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_float() { TestUtils.AreEqual(float.NegativeInfinity, round(float.NegativeInfinity)); @@ -2034,7 +2034,7 @@ public static void round_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), round(TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), round(float2(float.NegativeInfinity, -100.51f))); @@ -2045,7 +2045,7 @@ public static void round_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -100f), round(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -2054,7 +2054,7 @@ public static void round_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -100f, -100f), round(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -2062,7 +2062,7 @@ public static void round_float4() TestUtils.AreEqual(float4(102f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_double() { TestUtils.AreEqual(double.NegativeInfinity, round(double.NegativeInfinity)); @@ -2078,7 +2078,7 @@ public static void round_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), round(TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), round(double2(double.NegativeInfinity, -100.51))); @@ -2089,7 +2089,7 @@ public static void round_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -100.0), round(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -2098,7 +2098,7 @@ public static void round_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void round_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -100.0, -100.0), round(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -2106,7 +2106,7 @@ public static void round_double4() TestUtils.AreEqual(double4(102.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_float() { TestUtils.AreEqual(float.NegativeInfinity, trunc(float.NegativeInfinity)); @@ -2122,7 +2122,7 @@ public static void trunc_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), trunc(TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), trunc(float2(float.NegativeInfinity, -100.51f))); @@ -2133,7 +2133,7 @@ public static void trunc_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), trunc(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -2142,7 +2142,7 @@ public static void trunc_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), trunc(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -2150,7 +2150,7 @@ public static void trunc_float4() TestUtils.AreEqual(float4(101f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_double() { TestUtils.AreEqual(double.NegativeInfinity, trunc(double.NegativeInfinity)); @@ -2166,7 +2166,7 @@ public static void trunc_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), trunc(TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), trunc(double2(double.NegativeInfinity, -100.51))); @@ -2177,7 +2177,7 @@ public static void trunc_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), trunc(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -2186,7 +2186,7 @@ public static void trunc_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void trunc_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), trunc(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -2194,7 +2194,7 @@ public static void trunc_double4() TestUtils.AreEqual(double4(101.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(float.NegativeInfinity), 64, false); @@ -2206,7 +2206,7 @@ public static void frac_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(TestUtils.SignedFloatQNaN()), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), frac(float2(float.NegativeInfinity, -1E+20f)), 64, false); @@ -2215,7 +2215,7 @@ public static void frac_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0.7f), frac(float3(float.NegativeInfinity, -1E+20f, -100.3f)), 64, false); @@ -2223,14 +2223,14 @@ public static void frac_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 0.7f, 0f), frac(float4(float.NegativeInfinity, -1E+20f, -100.3f, 0f)), 64, false); TestUtils.AreEqual(float4(0.8f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float4(100.8f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(double.NegativeInfinity), 64, false); @@ -2242,7 +2242,7 @@ public static void frac_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(TestUtils.SignedDoubleQNaN()), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), frac(double2(double.NegativeInfinity, -1E+20)), 64, false); @@ -2251,7 +2251,7 @@ public static void frac_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.7), frac(double3(double.NegativeInfinity, -1E+20, -100.3)), 64, false); @@ -2259,14 +2259,14 @@ public static void frac_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void frac_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 0.7, 0.0), frac(double4(double.NegativeInfinity, -1E+20, -100.3, 0.0)), 64, false); TestUtils.AreEqual(double4(0.8, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double4(100.8, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_float() { TestUtils.AreEqual(-967.77f, lerp(-123.45f, 439.43f, -1.5f), 1, false); @@ -2275,27 +2275,27 @@ public static void lerp_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), lerp(-123.45f, 439.43f, TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_float2() { TestUtils.AreEqual(float2(-967.77f, 157.99f), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-1.5f, 0.5f)), 1, false); TestUtils.AreEqual(float2(2972.39f, TestUtils.SignedFloatQNaN()), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(5.5f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_float3() { TestUtils.AreEqual(float3(-967.77f, 157.99f, 2972.39f), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-1.5f, 0.5f, 5.5f)), 1, false); TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_float4() { TestUtils.AreEqual(float4(-967.77f, 157.99f, 2972.39f, TestUtils.SignedFloatQNaN()), lerp(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f), float4(-1.5f, 0.5f, 5.5f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_double() { TestUtils.AreEqual(-967.77, lerp(-123.45, 439.43, -1.5), 1, false); @@ -2304,27 +2304,27 @@ public static void lerp_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), lerp(-123.45, 439.43, TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_double2() { TestUtils.AreEqual(double2(-967.77, 157.99), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-1.5, 0.5)), 1, false); TestUtils.AreEqual(double2(2972.39, TestUtils.SignedDoubleQNaN()), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(5.5, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_double3() { TestUtils.AreEqual(double3(-967.77, 157.99, 2972.39), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-1.5, 0.5, 5.5)), 1, false); TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void lerp_double4() { TestUtils.AreEqual(double4(-967.77, 157.99, 2972.39, TestUtils.SignedDoubleQNaN()), lerp(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43), double4(-1.5, 0.5, 5.5, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_float() { TestUtils.AreEqual(-0.232465178f, unlerp(-123.45f, 439.43f, -254.3f), 4, false); @@ -2337,7 +2337,7 @@ public static void unlerp_float() TestUtils.AreEqual(-0.3422932f, unlerp(439.43f, -123.45f, 632.1f), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_float2() { TestUtils.AreEqual(float2(-0.232465178f, 0.219318509f), unlerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-254.3f, 0f)), 4, false); @@ -2346,7 +2346,7 @@ public static void unlerp_float2() TestUtils.AreEqual(float2(0.7806815f, -0.3422932f), unlerp(float2(439.43f, 439.43f), float2(-123.45f, -123.45f), float2(0f, 632.1f)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_float3() { TestUtils.AreEqual(float3(-0.232465178f, 0.219318509f, 1.34229326f), unlerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-254.3f, 0f, 632.1f)), 4, false); @@ -2354,14 +2354,14 @@ public static void unlerp_float3() TestUtils.AreEqual(float3(0.7806815f, -0.3422932f, -0.3422932f), unlerp(float3(439.43f, 439.43f, 439.43f), float3(-123.45f, -123.45f, -123.45f), float3(0f, 632.1f, 632.1f)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_float4() { TestUtils.AreEqual(float4(-0.232465178f, 0.219318509f, 1.34229326f, float.NegativeInfinity), unlerp(float4(-123.45f, -123.45f, -123.45f, 123.4f), float4(439.43f, 439.43f, 439.43f, 123.4f), float4(-254.3f, 0f, 632.1f, -430f)), 4, false); TestUtils.AreEqual(float4(float.PositiveInfinity, 1.23246515f, 0.7806815f, -0.3422932f), unlerp(float4(123.4f, 439.43f, 439.43f, 439.43f), float4(123.4f, -123.45f, -123.45f, -123.45f), float4(430f, -254.3f, 0f, 632.1f)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_double() { TestUtils.AreEqual(-0.23246517907902217, unlerp(-123.45, 439.43, -254.3), 4, false); @@ -2374,7 +2374,7 @@ public static void unlerp_double() TestUtils.AreEqual(-0.34229320636725413, unlerp(439.43, -123.45, 632.1), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_double2() { TestUtils.AreEqual(double2(-0.23246517907902217, 0.21931850483229107), unlerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-254.3, 0.0)), 4, false); @@ -2383,7 +2383,7 @@ public static void unlerp_double2() TestUtils.AreEqual(double2(0.78068149516770891, -0.34229320636725413), unlerp(double2(439.43, 439.43), double2(-123.45, -123.45), double2(0.0, 632.1)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_double3() { TestUtils.AreEqual(double3(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541), unlerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-254.3, 0.0, 632.1)), 4, false); @@ -2391,14 +2391,14 @@ public static void unlerp_double3() TestUtils.AreEqual(double3(0.78068149516770891, -0.34229320636725413, -0.34229320636725413), unlerp(double3(439.43, 439.43, 439.43), double3(-123.45, -123.45, -123.45), double3(0.0, 632.1, 632.1)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void unlerp_double4() { TestUtils.AreEqual(double4(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541, double.NegativeInfinity), unlerp(double4(-123.45, -123.45, -123.45, 123.4), double4(439.43, 439.43, 439.43, 123.4), double4(-254.3, 0.0, 632.1, -430.0)), 4, false); TestUtils.AreEqual(double4(double.PositiveInfinity, 1.2324651790790222, 0.78068149516770891, -0.34229320636725413), unlerp(double4(123.4, 439.43, 439.43, 439.43), double4(123.4, -123.45, -123.45, -123.45), double4(430.0, -254.3, 0.0, 632.1)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_float() { TestUtils.AreEqual(529.0331f, remap(-123.45f, 439.43f, 541.3f, 631.5f, -200f), 4, false); @@ -2414,7 +2414,7 @@ public static void remap_float() TestUtils.AreEqual(float.PositiveInfinity, remap(-123.45f, -123.45f, 541.3f, 631.5f, -100f), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_float2() { TestUtils.AreEqual(float2(529.0331f, 545.0578f), remap(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-200f, -100f)), 4, false); @@ -2425,7 +2425,7 @@ public static void remap_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), remap(float2(-123.45f, -123.45f), float2(-123.45f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-100f, -100f)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_float3() { TestUtils.AreEqual(float3(529.0331f, 545.0578f, 641.2062f), remap(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, 500f)), 4, false); @@ -2434,7 +2434,7 @@ public static void remap_float3() TestUtils.AreEqual(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float3(-123.45f, -123.45f, -123.45f), float3(-123.45f, -123.45f, -123.45f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, -100f)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_float4() { TestUtils.AreEqual(float4(529.0331f, 545.0578f, 641.2062f, 643.7669f), remap(float4(-123.45f, -123.45f, -123.45f, 439.43f), float4(439.43f, 439.43f, 439.43f, -123.45f), float4(541.3f, 541.3f, 541.3f, 541.3f), float4(631.5f, 631.5f, 631.5f, 631.5f), float4(-200f, -100f, 500f, -200f)), 4, false); @@ -2442,7 +2442,7 @@ public static void remap_float4() TestUtils.AreEqual(float4(531.5938f, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, -123.45f, -123.45f, -123.45f), float4(631.5f, 541.3f, 541.3f, 541.3f), float4(541.3f, 631.5f, 631.5f, 631.5f), float4(500f, -200f, -100f, -100f)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_double() { TestUtils.AreEqual(529.03306921546334, remap(-123.45, 439.43, 541.3, 631.5, -200.0), 4, false); @@ -2458,7 +2458,7 @@ public static void remap_double() TestUtils.AreEqual(double.PositiveInfinity, remap(-123.45, -123.45, 541.3, 631.5, -100.0), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_double2() { TestUtils.AreEqual(double2(529.03306921546334, 545.057799175668), remap(double2(-123.45, -123.45), double2(439.43, 439.43), double2(541.3, 541.3), double2(631.5, 631.5), double2(-200.0, -100.0)), 4, false); @@ -2469,7 +2469,7 @@ public static void remap_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), remap(double2(-123.45, -123.45), double2(-123.45, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(-100.0, -100.0)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_double3() { TestUtils.AreEqual(double3(529.03306921546334, 545.057799175668, 641.206178936896), remap(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, 500.0)), 4, false); @@ -2478,7 +2478,7 @@ public static void remap_double3() TestUtils.AreEqual(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double3(-123.45, -123.45, -123.45), double3(-123.45, -123.45, -123.45), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, -100.0)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void remap_double4() { TestUtils.AreEqual(double4(529.03306921546334, 545.057799175668, 641.206178936896, 643.76693078453673), remap(double4(-123.45, -123.45, -123.45, 439.43), double4(439.43, 439.43, 439.43, -123.45), double4(541.3, 541.3, 541.3, 541.3), double4(631.5, 631.5, 631.5, 631.5), double4(-200.0, -100.0, 500.0, -200.0)), 4, false); @@ -2486,7 +2486,7 @@ public static void remap_double4() TestUtils.AreEqual(double4(531.59382106310409, double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, -123.45, -123.45, -123.45), double4(631.5, 541.3, 541.3, 541.3), double4(541.3, 631.5, 631.5, 631.5), double4(500.0, -200.0, -100.0, -100.0)), 4, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_int() { TestUtils.AreEqual(-123, clamp(-2147483648, -123, 439)); @@ -2499,7 +2499,7 @@ public static void clamp_int() TestUtils.AreEqual(439, clamp(2147483647, -123, 439)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_int2() { TestUtils.AreEqual(int2(-123, -123), clamp(int2(-2147483648, -254), int2(-123, -123), int2(439, 439))); @@ -2508,7 +2508,7 @@ public static void clamp_int2() TestUtils.AreEqual(int2(439, 439), clamp(int2(632, 2147483647), int2(439, -123), int2(-123, 439))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_int3() { TestUtils.AreEqual(int3(-123, -123, 246), clamp(int3(-2147483648, -254, 246), int3(-123, -123, -123), int3(439, 439, 439))); @@ -2516,14 +2516,14 @@ public static void clamp_int3() TestUtils.AreEqual(int3(439, 439, 439), clamp(int3(632, 2147483647, 2147483647), int3(439, -123, -123), int3(-123, 439, 439))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_int4() { TestUtils.AreEqual(int4(-123, -123, 246, 439), clamp(int4(-2147483648, -254, 246, 632), int4(-123, -123, -123, -123), int4(439, 439, 439, 439))); TestUtils.AreEqual(int4(439, 439, 439, 439), clamp(int4(-254, 246, 632, 2147483647), int4(439, 439, 439, -123), int4(-123, -123, -123, 439))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_uint() { TestUtils.AreEqual(123u, clamp(0u, 123u, 439u)); @@ -2536,7 +2536,7 @@ public static void clamp_uint() TestUtils.AreEqual(439u, clamp(4294967295u, 123u, 439u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_uint2() { TestUtils.AreEqual(uint2(123u, 123u), clamp(uint2(0u, 54u), uint2(123u, 123u), uint2(439u, 439u))); @@ -2545,7 +2545,7 @@ public static void clamp_uint2() TestUtils.AreEqual(uint2(439u, 439u), clamp(uint2(632u, 4294967295u), uint2(439u, 123u), uint2(123u, 439u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_uint3() { TestUtils.AreEqual(uint3(123u, 123u, 246u), clamp(uint3(0u, 54u, 246u), uint3(123u, 123u, 123u), uint3(439u, 439u, 439u))); @@ -2553,14 +2553,14 @@ public static void clamp_uint3() TestUtils.AreEqual(uint3(439u, 439u, 439u), clamp(uint3(632u, 4294967295u, 4294967295u), uint3(439u, 123u, 123u), uint3(123u, 439u, 439u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_uint4() { TestUtils.AreEqual(uint4(123u, 123u, 246u, 439u), clamp(uint4(0u, 54u, 246u, 632u), uint4(123u, 123u, 123u, 123u), uint4(439u, 439u, 439u, 439u))); TestUtils.AreEqual(uint4(439u, 439u, 439u, 439u), clamp(uint4(54u, 246u, 632u, 4294967295u), uint4(439u, 439u, 439u, 123u), uint4(123u, 123u, 123u, 439u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_long() { TestUtils.AreEqual(-123L, clamp(-9223372036854775808L, -123L, 439L)); @@ -2573,7 +2573,7 @@ public static void clamp_long() TestUtils.AreEqual(439L, clamp(9223372036854775807L, -123L, 439L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_ulong() { TestUtils.AreEqual(123UL, clamp(0UL, 123UL, 439UL)); @@ -2586,7 +2586,7 @@ public static void clamp_ulong() TestUtils.AreEqual(439UL, clamp(18446744073709551615UL, 123UL, 439UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_float() { TestUtils.AreEqual(-123.45f, clamp(float.NegativeInfinity, -123.45f, 439.43f)); @@ -2600,7 +2600,7 @@ public static void clamp_float() TestUtils.AreEqual(439.43f, clamp(TestUtils.SignedFloatQNaN(), -123.45f, 439.43f)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_float2() { TestUtils.AreEqual(float2(-123.45f, -123.45f), clamp(float2(float.NegativeInfinity, -254.3f), float2(-123.45f, -123.45f), float2(439.43f, 439.43f))); @@ -2610,7 +2610,7 @@ public static void clamp_float2() TestUtils.AreEqual(float2(439.43f, 439.43f), clamp(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(-123.45f, -123.45f), float2(439.43f, 439.43f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_float3() { TestUtils.AreEqual(float3(-123.45f, -123.45f, 246.3f), clamp(float3(float.NegativeInfinity, -254.3f, 246.3f), float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f))); @@ -2618,7 +2618,7 @@ public static void clamp_float3() TestUtils.AreEqual(float3(439.43f, 439.43f, 439.43f), clamp(float3(632.1f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(439.43f, -123.45f, -123.45f), float3(-123.45f, 439.43f, 439.43f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_float4() { TestUtils.AreEqual(float4(-123.45f, -123.45f, 246.3f, 439.43f), clamp(float4(float.NegativeInfinity, -254.3f, 246.3f, 632.1f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f))); @@ -2626,7 +2626,7 @@ public static void clamp_float4() TestUtils.AreEqual(float4(439.43f, 439.43f, 439.43f, 439.43f), clamp(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_double() { TestUtils.AreEqual(-123.45, clamp(double.NegativeInfinity, -123.45, 439.43)); @@ -2640,7 +2640,7 @@ public static void clamp_double() TestUtils.AreEqual(439.43, clamp(TestUtils.SignedDoubleQNaN(), -123.45, 439.43)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_double2() { TestUtils.AreEqual(double2(-123.45, -123.45), clamp(double2(double.NegativeInfinity, -254.3), double2(-123.45, -123.45), double2(439.43, 439.43))); @@ -2650,7 +2650,7 @@ public static void clamp_double2() TestUtils.AreEqual(double2(439.43, 439.43), clamp(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(-123.45, -123.45), double2(439.43, 439.43))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_double3() { TestUtils.AreEqual(double3(-123.45, -123.45, 246.3), clamp(double3(double.NegativeInfinity, -254.3, 246.3), double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43))); @@ -2658,7 +2658,7 @@ public static void clamp_double3() TestUtils.AreEqual(double3(439.43, 439.43, 439.43), clamp(double3(632.1, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(439.43, -123.45, -123.45), double3(-123.45, 439.43, 439.43))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void clamp_double4() { TestUtils.AreEqual(double4(-123.45, -123.45, 246.3, 439.43), clamp(double4(double.NegativeInfinity, -254.3, 246.3, 632.1), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43))); @@ -2666,7 +2666,7 @@ public static void clamp_double4() TestUtils.AreEqual(double4(439.43, 439.43, 439.43, 439.43), clamp(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_float() { TestUtils.AreEqual(0f, saturate(float.NegativeInfinity)); @@ -2679,7 +2679,7 @@ public static void saturate_float() TestUtils.AreEqual(1f, saturate(TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_float2() { TestUtils.AreEqual(float2(0f, 0f), saturate(float2(float.NegativeInfinity, -123.45f))); @@ -2688,7 +2688,7 @@ public static void saturate_float2() TestUtils.AreEqual(float2(1f, 1f), saturate(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_float3() { TestUtils.AreEqual(float3(0f, 0f, 0f), saturate(float3(float.NegativeInfinity, -123.45f, 0f))); @@ -2696,14 +2696,14 @@ public static void saturate_float3() TestUtils.AreEqual(float3(1f, 1f, 1f), saturate(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_float4() { TestUtils.AreEqual(float4(0f, 0f, 0f, 0.5f), saturate(float4(float.NegativeInfinity, -123.45f, 0f, 0.5f))); TestUtils.AreEqual(float4(1f, 1f, 1f, 1f), saturate(float4(1f, 123.45f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_double() { TestUtils.AreEqual(0.0, saturate(double.NegativeInfinity)); @@ -2716,7 +2716,7 @@ public static void saturate_double() TestUtils.AreEqual(1.0, saturate(TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_double2() { TestUtils.AreEqual(double2(0.0, 0.0), saturate(double2(double.NegativeInfinity, -123.45))); @@ -2725,7 +2725,7 @@ public static void saturate_double2() TestUtils.AreEqual(double2(1.0, 1.0), saturate(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_double3() { TestUtils.AreEqual(double3(0.0, 0.0, 0.0), saturate(double3(double.NegativeInfinity, -123.45, 0.0))); @@ -2733,14 +2733,14 @@ public static void saturate_double3() TestUtils.AreEqual(double3(1.0, 1.0, 1.0), saturate(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void saturate_double4() { TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.5), saturate(double4(double.NegativeInfinity, -123.45, 0.0, 0.5))); TestUtils.AreEqual(double4(1.0, 1.0, 1.0, 1.0), saturate(double4(1.0, 123.45, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_float() { TestUtils.AreEqual(0f, step(-123.45f, float.NegativeInfinity)); @@ -2770,7 +2770,7 @@ public static void step_float() TestUtils.AreEqual(0f, step(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_float2() { TestUtils.AreEqual(float2(0f, 0f), step(float2(-123.45f, -123.45f), float2(float.NegativeInfinity, -200f))); @@ -2788,7 +2788,7 @@ public static void step_float2() TestUtils.AreEqual(float2(0f, 0f), step(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_float3() { TestUtils.AreEqual(float3(0f, 0f, 1f), step(float3(-123.45f, -123.45f, -123.45f), float3(float.NegativeInfinity, -200f, 200f))); @@ -2802,7 +2802,7 @@ public static void step_float3() TestUtils.AreEqual(float3(0f, 0f, 0f), step(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_float4() { TestUtils.AreEqual(float4(0f, 0f, 1f, 1f), step(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(float.NegativeInfinity, -200f, 200f, float.PositiveInfinity))); @@ -2814,7 +2814,7 @@ public static void step_float4() TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), step(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_double() { TestUtils.AreEqual(0.0, step(-123.45, double.NegativeInfinity)); @@ -2844,7 +2844,7 @@ public static void step_double() TestUtils.AreEqual(0.0, step(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_double2() { TestUtils.AreEqual(double2(0.0, 0.0), step(double2(-123.45, -123.45), double2(double.NegativeInfinity, -200.0))); @@ -2862,7 +2862,7 @@ public static void step_double2() TestUtils.AreEqual(double2(0.0, 0.0), step(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_double3() { TestUtils.AreEqual(double3(0.0, 0.0, 1.0), step(double3(-123.45, -123.45, -123.45), double3(double.NegativeInfinity, -200.0, 200.0))); @@ -2876,7 +2876,7 @@ public static void step_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), step(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void step_double4() { TestUtils.AreEqual(double4(0.0, 0.0, 1.0, 1.0), step(double4(-123.45, -123.45, -123.45, -123.45), double4(double.NegativeInfinity, -200.0, 200.0, double.PositiveInfinity))); @@ -2888,7 +2888,7 @@ public static void step_double4() TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), step(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_int() { TestUtils.AreEqual(-2147483648, min(-2147483648, -2147483648)); @@ -2906,7 +2906,7 @@ public static void min_int() TestUtils.AreEqual(2147483647, min(2147483647, 2147483647)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_int2() { TestUtils.AreEqual(int2(-2147483648, -2147483648), min(int2(-2147483648, -2147483648), int2(-2147483648, -1))); @@ -2918,7 +2918,7 @@ public static void min_int2() TestUtils.AreEqual(int2(2147483647, 2147483647), min(int2(2147483647, 2147483647), int2(2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_int3() { TestUtils.AreEqual(int3(-2147483648, -2147483648, -2147483648), min(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648))); @@ -2928,7 +2928,7 @@ public static void min_int3() TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), min(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_int4() { TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -3456), min(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456))); @@ -2937,7 +2937,7 @@ public static void min_int4() TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), min(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_uint() { TestUtils.AreEqual(1234u, min(1234u, 3456u)); @@ -2949,7 +2949,7 @@ public static void min_uint() TestUtils.AreEqual(4294967295u, min(4294967295u, 4294967295u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_uint2() { TestUtils.AreEqual(uint2(1234u, 1234u), min(uint2(1234u, 3456u), uint2(3456u, 1234u))); @@ -2958,7 +2958,7 @@ public static void min_uint2() TestUtils.AreEqual(uint2(4294967295u, 4294967295u), min(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_uint3() { TestUtils.AreEqual(uint3(1234u, 1234u, 7u), min(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u))); @@ -2966,14 +2966,14 @@ public static void min_uint3() TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), min(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_uint4() { TestUtils.AreEqual(uint4(1234u, 1234u, 7u, 7u), min(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u))); TestUtils.AreEqual(uint4(1u, 1u, 4294967295u, 4294967295u), min(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_long() { TestUtils.AreEqual(-9223372036854775808L, min(-9223372036854775808L, -9223372036854775808L)); @@ -2991,7 +2991,7 @@ public static void min_long() TestUtils.AreEqual(9223372036854775807L, min(9223372036854775807L, 9223372036854775807L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_ulong() { TestUtils.AreEqual(1234UL, min(1234UL, 3456UL)); @@ -3003,7 +3003,7 @@ public static void min_ulong() TestUtils.AreEqual(18446744073709551615UL, min(18446744073709551615UL, 18446744073709551615UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_float() { TestUtils.AreEqual(float.NegativeInfinity, min(float.NegativeInfinity, float.NegativeInfinity)); @@ -3024,7 +3024,7 @@ public static void min_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), min(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, float.NegativeInfinity), min(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f))); @@ -3037,7 +3037,7 @@ public static void min_float2() TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), min(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), min(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity))); @@ -3048,7 +3048,7 @@ public static void min_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), min(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -3456.7f), min(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f))); @@ -3057,7 +3057,7 @@ public static void min_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), min(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_double() { TestUtils.AreEqual(double.NegativeInfinity, min(double.NegativeInfinity, double.NegativeInfinity)); @@ -3078,7 +3078,7 @@ public static void min_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), min(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, double.NegativeInfinity), min(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0))); @@ -3091,7 +3091,7 @@ public static void min_double2() TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), min(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity), min(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity))); @@ -3102,7 +3102,7 @@ public static void min_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), min(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void min_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -3456.7), min(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7))); @@ -3111,7 +3111,7 @@ public static void min_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), min(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_int() { TestUtils.AreEqual(-2147483648, max(-2147483648, -2147483648)); @@ -3129,7 +3129,7 @@ public static void max_int() TestUtils.AreEqual(2147483647, max(2147483647, 2147483647)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_int2() { TestUtils.AreEqual(int2(-2147483648, -1), max(int2(-2147483648, -2147483648), int2(-2147483648, -1))); @@ -3141,7 +3141,7 @@ public static void max_int2() TestUtils.AreEqual(int2(2147483647, 2147483647), max(int2(2147483647, 2147483647), int2(2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_int3() { TestUtils.AreEqual(int3(-2147483648, -1, -1), max(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648))); @@ -3151,7 +3151,7 @@ public static void max_int3() TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), max(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_int4() { TestUtils.AreEqual(int4(-2147483648, -1, -1, -1234), max(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456))); @@ -3160,7 +3160,7 @@ public static void max_int4() TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), max(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_uint() { TestUtils.AreEqual(3456u, max(1234u, 3456u)); @@ -3172,7 +3172,7 @@ public static void max_uint() TestUtils.AreEqual(4294967295u, max(4294967295u, 4294967295u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_uint2() { TestUtils.AreEqual(uint2(3456u, 3456u), max(uint2(1234u, 3456u), uint2(3456u, 1234u))); @@ -3181,7 +3181,7 @@ public static void max_uint2() TestUtils.AreEqual(uint2(4294967295u, 4294967295u), max(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_uint3() { TestUtils.AreEqual(uint3(3456u, 3456u, 4294967040u), max(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u))); @@ -3189,14 +3189,14 @@ public static void max_uint3() TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), max(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_uint4() { TestUtils.AreEqual(uint4(3456u, 3456u, 4294967040u, 4294967040u), max(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u))); TestUtils.AreEqual(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u), max(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_long() { TestUtils.AreEqual(-9223372036854775808L, max(-9223372036854775808L, -9223372036854775808L)); @@ -3214,7 +3214,7 @@ public static void max_long() TestUtils.AreEqual(9223372036854775807L, max(9223372036854775807L, 9223372036854775807L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_ulong() { TestUtils.AreEqual(3456UL, max(1234UL, 3456UL)); @@ -3226,7 +3226,7 @@ public static void max_ulong() TestUtils.AreEqual(18446744073709551615UL, max(18446744073709551615UL, 18446744073709551615UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_float() { TestUtils.AreEqual(float.NegativeInfinity, max(float.NegativeInfinity, float.NegativeInfinity)); @@ -3247,7 +3247,7 @@ public static void max_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), max(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -1f), max(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f))); @@ -3260,7 +3260,7 @@ public static void max_float2() TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), max(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -1f, -1f), max(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity))); @@ -3271,7 +3271,7 @@ public static void max_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), max(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -1f, -1f, -1234.56f), max(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f))); @@ -3280,7 +3280,7 @@ public static void max_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), max(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_double() { TestUtils.AreEqual(double.NegativeInfinity, max(double.NegativeInfinity, double.NegativeInfinity)); @@ -3301,7 +3301,7 @@ public static void max_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), max(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -1.0), max(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0))); @@ -3314,7 +3314,7 @@ public static void max_double2() TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), max(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -1.0, -1.0), max(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity))); @@ -3325,7 +3325,7 @@ public static void max_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), max(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void max_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -1.0, -1.0, -1234.56), max(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7))); @@ -3334,7 +3334,7 @@ public static void max_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), max(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_float() { TestUtils.AreEqual(0f, smoothstep(-123.45f, 345.6f, float.NegativeInfinity), 8, false); @@ -3351,7 +3351,7 @@ public static void smoothstep_float() TestUtils.AreEqual(1f, smoothstep(345.6f, -123.45f, TestUtils.SignedFloatQNaN()), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_float2() { TestUtils.AreEqual(float2(0f, 0f), smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(float.NegativeInfinity, -200f)), 8, false); @@ -3362,7 +3362,7 @@ public static void smoothstep_float2() TestUtils.AreEqual(float2(0f, 1f), smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_float3() { TestUtils.AreEqual(float3(0f, 0f, 0.00724848127f), smoothstep(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(float.NegativeInfinity, -200f, -100f)), 8, false); @@ -3371,7 +3371,7 @@ public static void smoothstep_float3() TestUtils.AreEqual(float3(0f, 0f, 1f), smoothstep(float3(345.6f, 345.6f, 345.6f), float3(-123.45f, -123.45f, -123.45f), float3(400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_float4() { TestUtils.AreEqual(float4(0f, 0f, 0.00724848127f, 1f), smoothstep(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(345.6f, 345.6f, 345.6f, 345.6f), float4(float.NegativeInfinity, -200f, -100f, 400f)), 8, false); @@ -3379,7 +3379,7 @@ public static void smoothstep_float4() TestUtils.AreEqual(float4(0.992751539f, 0f, 0f, 1f), smoothstep(float4(345.6f, 345.6f, 345.6f, 345.6f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(-100f, 400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_double() { TestUtils.AreEqual(0.0, smoothstep(-123.45, 345.6, double.NegativeInfinity), 8, false); @@ -3396,7 +3396,7 @@ public static void smoothstep_double() TestUtils.AreEqual(1.0, smoothstep(345.6, -123.45, TestUtils.SignedDoubleQNaN()), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_double2() { TestUtils.AreEqual(double2(0.0, 0.0), smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(double.NegativeInfinity, -200.0)), 8, false); @@ -3407,7 +3407,7 @@ public static void smoothstep_double2() TestUtils.AreEqual(double2(0.0, 1.0), smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_double3() { TestUtils.AreEqual(double3(0.0, 0.0, 0.0072484810488798995), smoothstep(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(double.NegativeInfinity, -200.0, -100.0)), 8, false); @@ -3416,7 +3416,7 @@ public static void smoothstep_double3() TestUtils.AreEqual(double3(0.0, 0.0, 1.0), smoothstep(double3(345.6, 345.6, 345.6), double3(-123.45, -123.45, -123.45), double3(400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void smoothstep_double4() { TestUtils.AreEqual(double4(0.0, 0.0, 0.0072484810488798995, 1.0), smoothstep(double4(-123.45, -123.45, -123.45, -123.45), double4(345.6, 345.6, 345.6, 345.6), double4(double.NegativeInfinity, -200.0, -100.0, 400.0)), 8, false); @@ -3424,7 +3424,7 @@ public static void smoothstep_double4() TestUtils.AreEqual(double4(0.99275151895112013, 0.0, 0.0, 1.0), smoothstep(double4(345.6, 345.6, 345.6, 345.6), double4(-123.45, -123.45, -123.45, -123.45), double4(-100.0, 400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_int() { TestUtils.AreEqual(7097663, mad(1234, 5678, 91011)); @@ -3445,7 +3445,7 @@ public static void mad_int() TestUtils.AreEqual(1313707278, mad(-98765, -56789, -91011)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_int2() { TestUtils.AreEqual(int2(7097663, 6915641), mad(int2(1234, 1234), int2(5678, 5678), int2(91011, -91011))); @@ -3458,7 +3458,7 @@ public static void mad_int2() TestUtils.AreEqual(int2(1313889300, 1313707278), mad(int2(-98765, -98765), int2(-56789, -56789), int2(91011, -91011))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_int3() { TestUtils.AreEqual(int3(7097663, 6915641, -6915641), mad(int3(1234, 1234, 1234), int3(5678, 5678, -5678), int3(91011, -91011, 91011))); @@ -3469,7 +3469,7 @@ public static void mad_int3() TestUtils.AreEqual(int3(1313707278, 1313707278, 1313707278), mad(int3(-98765, -98765, -98765), int3(-56789, -56789, -56789), int3(-91011, -91011, -91011))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_int4() { TestUtils.AreEqual(int4(7097663, 6915641, -6915641, -7097663), mad(int4(1234, 1234, 1234, 1234), int4(5678, 5678, -5678, -5678), int4(91011, -91011, 91011, -91011))); @@ -3478,32 +3478,32 @@ public static void mad_int4() TestUtils.AreEqual(int4(-1313707278, -1313889300, 1313889300, 1313707278), mad(int4(-98765, -98765, -98765, -98765), int4(56789, 56789, -56789, -56789), int4(91011, -91011, 91011, -91011))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_uint() { TestUtils.AreEqual(7097663u, mad(1234u, 5678u, 91011u)); TestUtils.AreEqual(1313889300u, mad(98765u, 56789u, 91011u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_uint2() { TestUtils.AreEqual(uint2(7097663u, 1313889300u), mad(uint2(1234u, 98765u), uint2(5678u, 56789u), uint2(91011u, 91011u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_uint3() { TestUtils.AreEqual(uint3(7097663u, 1313889300u, 1313889300u), mad(uint3(1234u, 98765u, 98765u), uint3(5678u, 56789u, 56789u), uint3(91011u, 91011u, 91011u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_uint4() { TestUtils.AreEqual(uint4(7097663u, 1313889300u, 1313889300u, 1313889300u), mad(uint4(1234u, 98765u, 98765u, 98765u), uint4(5678u, 56789u, 56789u, 56789u), uint4(91011u, 91011u, 91011u, 91011u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_long() { TestUtils.AreEqual(7097663L, mad(1234L, 5678L, 91011L)); @@ -3524,14 +3524,14 @@ public static void mad_long() TestUtils.AreEqual(747681192693554158L, mad(-9876543210L, -5678901234L, -9101112134L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_ulong() { TestUtils.AreEqual(7097663L, mad(1234UL, 5678UL, 91011UL)); TestUtils.AreEqual(747681210895778426L, mad(9876543210UL, 5678901234UL, 9101112134UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_float() { TestUtils.AreEqual(-42660f, mad(-123.45f, 345.6f, 4.321f), 1, false); @@ -3540,27 +3540,27 @@ public static void mad_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), mad(-123.45f, 345.6f, TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_float2() { TestUtils.AreEqual(float2(-42660f, TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, TestUtils.SignedFloatQNaN()), float2(345.6f, 345.6f), float2(4.321f, 4.321f)), 1, false); TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, -123.45f), float2(TestUtils.SignedFloatQNaN(), 345.6f), float2(4.321f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_float3() { TestUtils.AreEqual(float3(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f), float3(345.6f, 345.6f, TestUtils.SignedFloatQNaN()), float3(4.321f, 4.321f, 4.321f)), 1, false); TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_float4() { TestUtils.AreEqual(float4(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float4(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f, -123.45f), float4(345.6f, 345.6f, TestUtils.SignedFloatQNaN(), 345.6f), float4(4.321f, 4.321f, 4.321f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_double() { TestUtils.AreEqual(-42659.999, mad(-123.45, 345.6, 4.321), 1, false); @@ -3569,27 +3569,27 @@ public static void mad_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), mad(-123.45, 345.6, TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_double2() { TestUtils.AreEqual(double2(-42659.999, TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, TestUtils.SignedDoubleQNaN()), double2(345.6, 345.6), double2(4.321, 4.321)), 1, false); TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, -123.45), double2(TestUtils.SignedDoubleQNaN(), 345.6), double2(4.321, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_double3() { TestUtils.AreEqual(double3(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, TestUtils.SignedDoubleQNaN(), -123.45), double3(345.6, 345.6, TestUtils.SignedDoubleQNaN()), double3(4.321, 4.321, 4.321)), 1, false); TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void mad_double4() { TestUtils.AreEqual(double4(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double4(-123.45, TestUtils.SignedDoubleQNaN(), -123.45, -123.45), double4(345.6, 345.6, TestUtils.SignedDoubleQNaN(), 345.6), double4(4.321, 4.321, 4.321, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(float.NegativeInfinity, float.NegativeInfinity), 1, false); @@ -3643,7 +3643,7 @@ public static void fmod_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), -323.4f), fmod(float2(float.NegativeInfinity, -323.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3673,7 +3673,7 @@ public static void fmod_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero()), fmod(float3(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3695,7 +3695,7 @@ public static void fmod_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero(), 0f), fmod(float4(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3713,7 +3713,7 @@ public static void fmod_float4() TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(double.NegativeInfinity, double.NegativeInfinity), 1, false); @@ -3767,7 +3767,7 @@ public static void fmod_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), -323.4), fmod(double2(double.NegativeInfinity, -323.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -3797,7 +3797,7 @@ public static void fmod_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero()), fmod(double3(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -3819,7 +3819,7 @@ public static void fmod_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void fmod_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero(), 0.0), fmod(double4(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -3837,7 +3837,7 @@ public static void fmod_double4() TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_float() { TestUtils.AreEqual(0f, pow(float.NegativeInfinity, float.NegativeInfinity), 1, false); @@ -3887,7 +3887,7 @@ public static void pow_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), pow(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_float2() { TestUtils.AreEqual(float2(0f, 0f), pow(float2(float.NegativeInfinity, -3.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3915,7 +3915,7 @@ public static void pow_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_float3() { TestUtils.AreEqual(float3(0f, 0f, float.PositiveInfinity), pow(float3(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3935,7 +3935,7 @@ public static void pow_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float3(3.4f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_float4() { TestUtils.AreEqual(float4(0f, 0f, float.PositiveInfinity, float.PositiveInfinity), pow(float4(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3952,7 +3952,7 @@ public static void pow_float4() TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_double() { TestUtils.AreEqual(0.0, pow(double.NegativeInfinity, double.NegativeInfinity), 1, false); @@ -4002,7 +4002,7 @@ public static void pow_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), pow(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_double2() { TestUtils.AreEqual(double2(0.0, 0.0), pow(double2(double.NegativeInfinity, -3.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -4030,7 +4030,7 @@ public static void pow_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_double3() { TestUtils.AreEqual(double3(0.0, 0.0, double.PositiveInfinity), pow(double3(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -4050,7 +4050,7 @@ public static void pow_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double3(3.4, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void pow_double4() { TestUtils.AreEqual(double4(0.0, 0.0, double.PositiveInfinity, double.PositiveInfinity), pow(double4(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -4067,7 +4067,7 @@ public static void pow_double4() TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_int() { TestUtils.AreEqual(0, ceilpow2(0)); @@ -4079,7 +4079,7 @@ public static void ceilpow2_int() TestUtils.AreEqual(0, ceilpow2(-2147483647)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_int2() { TestUtils.AreEqual(int2(0, 1), ceilpow2(int2(0, 1))); @@ -4088,7 +4088,7 @@ public static void ceilpow2_int2() TestUtils.AreEqual(int2(0, 0), ceilpow2(int2(-2147483647, -2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_int3() { TestUtils.AreEqual(int3(0, 1, 2), ceilpow2(int3(0, 1, 2))); @@ -4096,14 +4096,14 @@ public static void ceilpow2_int3() TestUtils.AreEqual(int3(0, 0, 0), ceilpow2(int3(-2147483647, -2147483647, -2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_int4() { TestUtils.AreEqual(int4(0, 1, 2, 4), ceilpow2(int4(0, 1, 2, 3))); TestUtils.AreEqual(int4(1073741824, -2147483648, 0, 0), ceilpow2(int4(1019642234, 1823423423, -2147483647, -2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_uint() { TestUtils.AreEqual(0u, ceilpow2(0u)); @@ -4115,7 +4115,7 @@ public static void ceilpow2_uint() TestUtils.AreEqual(0u, ceilpow2(4294967295u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_uint2() { TestUtils.AreEqual(uint2(0u, 1u), ceilpow2(uint2(0u, 1u))); @@ -4124,7 +4124,7 @@ public static void ceilpow2_uint2() TestUtils.AreEqual(uint2(0u, 0u), ceilpow2(uint2(4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_uint3() { TestUtils.AreEqual(uint3(0u, 1u, 2u), ceilpow2(uint3(0u, 1u, 2u))); @@ -4132,14 +4132,14 @@ public static void ceilpow2_uint3() TestUtils.AreEqual(uint3(0u, 0u, 0u), ceilpow2(uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_uint4() { TestUtils.AreEqual(uint4(0u, 1u, 2u, 4u), ceilpow2(uint4(0u, 1u, 2u, 3u))); TestUtils.AreEqual(uint4(1073741824u, 2147483648u, 0u, 0u), ceilpow2(uint4(1019642234u, 1823423423u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_long() { TestUtils.AreEqual(0L, ceilpow2(0L)); @@ -4155,7 +4155,7 @@ public static void ceilpow2_long() TestUtils.AreEqual(0L, ceilpow2(-100L)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceilpow2_ulong() { TestUtils.AreEqual(0UL, ceilpow2(0UL)); @@ -4171,7 +4171,7 @@ public static void ceilpow2_ulong() TestUtils.AreEqual(0UL, ceilpow2(10223372036854775808UL)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_int() { TestUtils.AreEqual(0, floorlog2(1)); @@ -4185,7 +4185,7 @@ public static void floorlog2_int() TestUtils.AreEqual(30, floorlog2(2147483647)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_int2() { TestUtils.AreEqual(int2(0, 1), floorlog2(int2(1, 2))); @@ -4195,7 +4195,7 @@ public static void floorlog2_int2() TestUtils.AreEqual(int2(30, 30), floorlog2(int2(2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_int3() { TestUtils.AreEqual(int3(0, 1, 1), floorlog2(int3(1, 2, 3))); @@ -4203,7 +4203,7 @@ public static void floorlog2_int3() TestUtils.AreEqual(int3(15, 15, 30), floorlog2(int3(32768, 32769, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_int4() { TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(int4(1, 2, 3, 4))); @@ -4211,7 +4211,7 @@ public static void floorlog2_int4() TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_uint() { TestUtils.AreEqual(0, floorlog2(1u)); @@ -4225,7 +4225,7 @@ public static void floorlog2_uint() TestUtils.AreEqual(30, floorlog2(2147483647u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_uint2() { TestUtils.AreEqual(int2(0, 1), floorlog2(uint2(1u, 2u))); @@ -4235,7 +4235,7 @@ public static void floorlog2_uint2() TestUtils.AreEqual(int2(30, 30), floorlog2(uint2(2147483647u, 2147483647u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_uint3() { TestUtils.AreEqual(int3(0, 1, 1), floorlog2(uint3(1u, 2u, 3u))); @@ -4243,7 +4243,7 @@ public static void floorlog2_uint3() TestUtils.AreEqual(int3(15, 15, 30), floorlog2(uint3(32768u, 32769u, 2147483647u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void floorlog2_uint4() { TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(uint4(1u, 2u, 3u, 4u))); @@ -4251,7 +4251,7 @@ public static void floorlog2_uint4() TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(uint4(2147483647u, 2147483647u, 2147483647u, 2147483647u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_int() { TestUtils.AreEqual(0, ceillog2(1)); @@ -4269,7 +4269,7 @@ public static void ceillog2_int() TestUtils.AreEqual(31, ceillog2(2147483647)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_int2() { TestUtils.AreEqual(int2(0, 1), ceillog2(int2(1, 2))); @@ -4281,7 +4281,7 @@ public static void ceillog2_int2() TestUtils.AreEqual(int2(31, 31), ceillog2(int2(2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_int3() { TestUtils.AreEqual(int3(0, 1, 2), ceillog2(int3(1, 2, 3))); @@ -4291,7 +4291,7 @@ public static void ceillog2_int3() TestUtils.AreEqual(int3(31, 31, 31), ceillog2(int3(2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_int4() { TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(int4(1, 2, 3, 4))); @@ -4300,7 +4300,7 @@ public static void ceillog2_int4() TestUtils.AreEqual(int4(31, 31, 31, 31), ceillog2(int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_uint() { TestUtils.AreEqual(0, ceillog2(1u)); @@ -4318,7 +4318,7 @@ public static void ceillog2_uint() TestUtils.AreEqual(32, ceillog2(4294967295u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_uint2() { TestUtils.AreEqual(int2(0, 1), ceillog2(uint2(1u, 2u))); @@ -4330,7 +4330,7 @@ public static void ceillog2_uint2() TestUtils.AreEqual(int2(32, 32), ceillog2(uint2(4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_uint3() { TestUtils.AreEqual(int3(0, 1, 2), ceillog2(uint3(1u, 2u, 3u))); @@ -4340,7 +4340,7 @@ public static void ceillog2_uint3() TestUtils.AreEqual(int3(32, 32, 32), ceillog2(uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ceillog2_uint4() { TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(uint4(1u, 2u, 3u, 4u))); @@ -4349,7 +4349,7 @@ public static void ceillog2_uint4() TestUtils.AreEqual(int4(32, 32, 32, 32), ceillog2(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_int() { TestUtils.AreEqual(false, ispow2(-3)); @@ -4368,7 +4368,7 @@ public static void ispow2_int() TestUtils.AreEqual(false, ispow2(268431360)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_int2() { TestUtils.AreEqual(bool2(false, false), ispow2(int2(-3, -2))); @@ -4380,7 +4380,7 @@ public static void ispow2_int2() TestUtils.AreEqual(bool2(true, false), ispow2(int2(2097152, 268431360))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_int3() { TestUtils.AreEqual(bool3(false, false, false), ispow2(int3(-3, -2, -1))); @@ -4390,7 +4390,7 @@ public static void ispow2_int3() TestUtils.AreEqual(bool3(true, false, false), ispow2(int3(2097152, 268431360, 268431360))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_int4() { TestUtils.AreEqual(bool4(false, false, false, false), ispow2(int4(-3, -2, -1, 0))); @@ -4399,7 +4399,7 @@ public static void ispow2_int4() TestUtils.AreEqual(bool4(true, false, false, false), ispow2(int4(2097152, 268431360, 268431360, 268431360))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_uint() { TestUtils.AreEqual(false, ispow2(0u)); @@ -4416,7 +4416,7 @@ public static void ispow2_uint() TestUtils.AreEqual(false, ispow2(268431360u)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_uint2() { TestUtils.AreEqual(bool2(false, true), ispow2(uint2(0u, 1u))); @@ -4427,7 +4427,7 @@ public static void ispow2_uint2() TestUtils.AreEqual(bool2(false, false), ispow2(uint2(2097153u, 268431360u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_uint3() { TestUtils.AreEqual(bool3(false, true, true), ispow2(uint3(0u, 1u, 2u))); @@ -4436,7 +4436,7 @@ public static void ispow2_uint3() TestUtils.AreEqual(bool3(true, false, false), ispow2(uint3(2097152u, 2097153u, 268431360u))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ispow2_uint4() { TestUtils.AreEqual(bool4(false, true, true, false), ispow2(uint4(0u, 1u, 2u, 3u))); diff --git a/src/Tests/Tests/Shared/TestMatrix.cs b/src/Tests/Tests/Shared/TestMatrix.cs index 558ce482..5fc6a37b 100644 --- a/src/Tests/Tests/Shared/TestMatrix.cs +++ b/src/Tests/Tests/Shared/TestMatrix.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestMatrix { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_constructor_columns() { float2x2 a = float2x2(float2(1.0f, 2.0f), @@ -19,7 +19,7 @@ public static void float2x2_constructor_columns() TestUtils.AreEqual(4.0f, a.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_constructor_columns() { float3x3 a = float3x3(float3(1.0f, 2.0f, 3.0f), @@ -37,7 +37,7 @@ public static void float3x3_constructor_columns() TestUtils.AreEqual(9.0f, a.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_constructor_columns() { float4x4 a = float4x4(float4( 1.0f, 2.0f, 3.0f, 4.0f), @@ -63,7 +63,7 @@ public static void float4x4_constructor_columns() TestUtils.AreEqual(16.0f, a.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_constructor_scalars() { float2x2 a = float2x2(1.0f, 2.0f, @@ -75,7 +75,7 @@ public static void float2x2_constructor_scalars() TestUtils.AreEqual(4.0f, a.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_constructor_scalars() { float3x3 a = float3x3(1.0f, 2.0f, 3.0f, @@ -93,7 +93,7 @@ public static void float3x3_constructor_scalars() TestUtils.AreEqual(9.0f, a.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_constructor_scalars() { float4x4 a = float4x4( 1.0f, 2.0f, 3.0f, 4.0f, @@ -119,7 +119,7 @@ public static void float4x4_constructor_scalars() TestUtils.AreEqual(16.0f, a.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_constructor_float3x3() { float3x3 rot = float3x3(1.0f, 2.0f, 3.0f, @@ -136,7 +136,7 @@ public static void float4x4_constructor_float3x3() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_constructor_quaternion() { float3x3 m = float3x3(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f))); @@ -148,7 +148,7 @@ public static void float3x3_constructor_quaternion() TestUtils.AreEqual(r, m, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_constructor_quaternion_position() { float4x4 m = float4x4(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)), float3(1.0f, 2.0f, 3.0f)); @@ -161,7 +161,7 @@ public static void float4x4_constructor_quaternion_position() TestUtils.AreEqual(r, m, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_identity() { float2x2 a = float2x2.identity; @@ -171,7 +171,7 @@ public static void float2x2_identity() TestUtils.AreEqual(1.0f, a.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_identity() { float3x3 a = float3x3.identity; @@ -186,7 +186,7 @@ public static void float3x3_identity() TestUtils.AreEqual(1.0f, a.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_identity() { float4x4 a = float4x4.identity; @@ -208,7 +208,7 @@ public static void float4x4_identity() TestUtils.AreEqual(1.0f, a.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_rotate() { float epsilon = 0.0001f; @@ -220,7 +220,7 @@ public static void float2x2_rotate() TestUtils.AreEqual(cos(angle), m.c1.y, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_axis_angle() { float3 axis = normalize(float3(1.1f, 2.3f, -3.6f)); @@ -231,7 +231,7 @@ public static void float3x3_axis_angle() TestUtils.AreEqual(r, m, 0.00001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_axis_angle_consistency() { TestUtils.AreEqual(float3x3.RotateX(1.0f), float3x3.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f); @@ -239,7 +239,7 @@ public static void float3x3_axis_angle_consistency() TestUtils.AreEqual(float3x3.RotateZ(1.0f), float3x3.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_rotate_x() { float epsilon = 0.0001f; @@ -256,7 +256,7 @@ public static void float3x3_rotate_x() TestUtils.AreEqual(cos(angle), m.c2.z, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_rotate_y() { float epsilon = 0.0001f; @@ -273,7 +273,7 @@ public static void float3x3_rotate_y() TestUtils.AreEqual(cos(angle), m.c2.z, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_rotate_z() { float epsilon = 0.0001f; @@ -290,7 +290,7 @@ public static void float3x3_rotate_z() TestUtils.AreEqual(1.0f, m.c2.z, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_rotate_x_handedness() { float3 a = float3(0.0f, 0.3f, 0.7f); @@ -301,7 +301,7 @@ public static void float3x3_rotate_x_handedness() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_rotate_y_handedness() { float3 a = float3(0.3f, 0.0f, 0.7f); @@ -311,7 +311,7 @@ public static void float3x3_rotate_y_handedness() TestUtils.AreEqual(w > 0.0f, true); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_rotate_z_handedness() { float3 a = float3(0.3f, 0.7f, 0.0f); @@ -321,7 +321,7 @@ public static void float3x3_rotate_z_handedness() TestUtils.AreEqual(w > 0.0f, true); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_axis_angle() { float3 axis = normalize(float3(1.1f, 2.3f, -3.6f)); @@ -332,7 +332,7 @@ public static void float4x4_axis_angle() TestUtils.AreEqual(r, m, 0.00001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_axis_angle_consistency() { TestUtils.AreEqual(float4x4.RotateX(1.0f), float4x4.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f); @@ -340,7 +340,7 @@ public static void float4x4_axis_angle_consistency() TestUtils.AreEqual(float4x4.RotateZ(1.0f), float4x4.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_rotate_x() { float epsilon = 0.0001f; @@ -364,7 +364,7 @@ public static void float4x4_rotate_x() TestUtils.AreEqual(1.0f, m.c3.w, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_rotate_y() { float epsilon = 0.0001f; @@ -388,7 +388,7 @@ public static void float4x4_rotate_y() TestUtils.AreEqual(1.0f, m.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_rotate_z() { float epsilon = 0.0001f; @@ -412,7 +412,7 @@ public static void float4x4_rotate_z() TestUtils.AreEqual(1.0f, m.c3.w, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_rotate_x_handedness() { float3 a = float3(0.0f, 0.3f, 0.7f); @@ -423,7 +423,7 @@ public static void float4x4_rotate_x_handedness() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_rotate_y_handedness() { float3 a = float3(0.3f, 0.0f, 0.7f); @@ -433,7 +433,7 @@ public static void float4x4_rotate_y_handedness() TestUtils.AreEqual(w > 0.0f, true); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_rotate_z_handedness() { float3 a = float3(0.3f, 0.7f, 0.0f); @@ -480,7 +480,7 @@ public static void float4x4_rotate_z_handedness() static internal readonly float4x4 test4x4_zyx = new float4x4(test3x3_zyx, new float3(0, 0, 0)); - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_euler() { float3x3 m0_xyz = float3x3.EulerXYZ(test_angles); @@ -547,7 +547,7 @@ public static void float3x3_euler() TestUtils.AreEqual(test3x3_zyx, m3_zyx, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_euler() { float4x4 m0_xyz = float4x4.EulerXYZ(test_angles); @@ -614,7 +614,7 @@ public static void float4x4_euler() TestUtils.AreEqual(test4x4_zyx, m3_zyx, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_scale() { float2x2 m = float2x2(1.0f, 2.0f, @@ -635,7 +635,7 @@ public static void float2x2_scale() TestUtils.AreEqual(r1, c); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_scale() { float3x3 m = float3x3(1.0f, 2.0f, 3.0f, @@ -661,7 +661,7 @@ public static void float3x3_scale() TestUtils.AreEqual(r1, c); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_scale() { float4x4 m = float4x4( 1.0f, 2.0f, 3.0f, 4.0f, @@ -688,7 +688,7 @@ public static void float4x4_scale() TestUtils.AreEqual(r1, c); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_matrix_mul() { // http://www.wolframalpha.com/input/?i=%5B%5B1,2%5D,%5B3,4%5D%5D*%5B%5B21,22%5D,%5B23,24%5D%5D @@ -706,7 +706,7 @@ public static void float2x2_matrix_mul() TestUtils.AreEqual(162.0f, c.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_matrix_mul() { // http://www.wolframalpha.com/input/?i=%5B%5B1,2,3%5D,%5B4,5,6%5D,%5B7,8,9%5D%5D*%5B%5B21,22,23%5D,%5B24,25,26%5D,%5B27,28,29%5D%5D @@ -732,7 +732,7 @@ public static void float3x3_matrix_mul() TestUtils.AreEqual(630.0f, c.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_matrix_mul() { // https://fogbugz.unity3d.com/f/cases/1041176/ @@ -769,7 +769,7 @@ public static void float4x4_matrix_mul() TestUtils.AreEqual(1760.0f, c.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_transpose() { float2x2 a = float2x2(1.0f, 2.0f, @@ -783,7 +783,7 @@ public static void float2x2_transpose() TestUtils.AreEqual(4.0f, b.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_transpose() { float3x3 a = float3x3(1.0f, 2.0f, 3.0f, @@ -803,7 +803,7 @@ public static void float3x3_transpose() TestUtils.AreEqual(9.0f, b.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_transpose() { float4x4 a = float4x4( 1.0f, 2.0f, 3.0f, 4.0f, @@ -831,7 +831,7 @@ public static void float4x4_transpose() TestUtils.AreEqual(16.0f, b.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_inverse() { float2x2 a = float2x2( 0.542968f, 0.867379f, @@ -850,7 +850,7 @@ public static void float2x2_inverse() TestUtils.AreEqual(r.c1.y, invA.c1.y, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_inverse() { float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f, @@ -877,7 +877,7 @@ public static void float3x3_inverse() TestUtils.AreEqual(r.c2.z, invA.c2.z, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_inverse() { float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f,-0.943083f, @@ -914,7 +914,7 @@ public static void float4x4_inverse() TestUtils.AreEqual(r.c3.w, invA.c3.w, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x4_fastinverse() { float4x4 a = test4x4_xyz; @@ -931,7 +931,7 @@ public static void float3x4_fastinverse() TestUtils.AreEqual(invA.c3.xyz, fastInvB.c3.xyz, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_fastinverse() { float4x4 a = test4x4_xyz; @@ -943,7 +943,7 @@ public static void float4x4_fastinverse() TestUtils.AreEqual(invA, fastInvA, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2x2_determinant() { float2x2 a = float2x2(0.542968f, 0.867379f, @@ -953,7 +953,7 @@ public static void float2x2_determinant() TestUtils.AreEqual(-0.2610378f, det, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_determinant() { float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f, @@ -964,7 +964,7 @@ public static void float3x3_determinant() TestUtils.AreEqual(0.06019618f, det, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_determinant() { float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f, -0.943083f, @@ -976,7 +976,7 @@ public static void float4x4_determinant() TestUtils.AreEqual(0.5838502f, det, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_look_rotation() { float3 forward0 = normalize(float3(1.0f, 2.0f, 3.0f)); @@ -1012,7 +1012,7 @@ public static void float3x3_look_rotation() TestUtils.AreEqual(float3x3(quaternion.LookRotation(forward3, up3)), m3, 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_look_rotation_safe() { float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f; @@ -1029,7 +1029,7 @@ public static void float3x3_look_rotation_safe() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_lookat() { float4x4 m = float4x4.LookAt(float3(0.3f, -0.5f, 3.0f), float3(3.2f, -3.1f, 0.2f), normalize(float3(0.3f, 1.0f, -3.0f))); @@ -1043,7 +1043,7 @@ public static void float4x4_lookat() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_ortho() { float4x4 m = float4x4.Ortho(2.0f, 3.0f, -3.0f, 7.0f); @@ -1056,7 +1056,7 @@ public static void float4x4_ortho() TestUtils.AreEqual(r, m, 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_orthoOffCenter() { float4x4 m = float4x4.OrthoOffCenter(-2.0f, 1.0f, -3.0f, -1.0f, -3.0f, 7.0f); @@ -1069,7 +1069,7 @@ public static void float4x4_orthoOffCenter() TestUtils.AreEqual(r, m, 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_perspective() { float fovy = 1.6f; @@ -1098,7 +1098,7 @@ public static void float4x4_perspective() TestUtils.AreEqual(float3(1.0f, 1.0f, 1.0f), pp1.xyz, 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_perspectiveOffCenter() { float fovy = 1.6f; @@ -1132,7 +1132,7 @@ public static void float4x4_perspectiveOffCenter() TestUtils.AreEqual(float3(-1.0f, 1.0f, 1.0f), pp2.xyz, 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4x4_TRS() { float3 scale = float3(1.2f, -0.4f, 2.3f); @@ -1143,7 +1143,7 @@ public static void float4x4_TRS() TestUtils.AreEqual(r0, m0, 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_constructor_float4x4() { var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16)); @@ -1152,7 +1152,7 @@ public static void float3x3_constructor_float4x4() TestUtils.AreEqual(expected, new float3x3(f4x4)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_explicit_cast_float4x4() { var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16)); @@ -1161,7 +1161,7 @@ public static void float3x3_explicit_cast_float4x4() TestUtils.AreEqual(expected, (float3x3)f4x4); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_from_float4x4_without_new() { var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16)); @@ -1170,7 +1170,7 @@ public static void float3x3_from_float4x4_without_new() TestUtils.AreEqual(expected, float3x3(f4x4)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_pseudoinverse_non_singular() { const float kTolerance = 1e-5f; @@ -1191,7 +1191,7 @@ public static void float3x3_pseudoinverse_non_singular() TestUtils.AreEqual(expected, inverse(a), kTolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3x3_pseudoinverse_singular() { const float kTolerance = 1e-5f; diff --git a/src/Tests/Tests/Shared/TestMinMaxAABB.cs b/src/Tests/Tests/Shared/TestMinMaxAABB.cs index 7c5c5e8c..a08e52cd 100644 --- a/src/Tests/Tests/Shared/TestMinMaxAABB.cs +++ b/src/Tests/Tests/Shared/TestMinMaxAABB.cs @@ -9,7 +9,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestMinMaxAABB { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_trivial() { var aabb = new MinMaxAABB(); @@ -18,7 +18,7 @@ public static void Encapsulate_float3_trivial() TestUtils.AreEqual(float3.zero, aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_max() { var aabb = new MinMaxAABB(); @@ -27,7 +27,7 @@ public static void Encapsulate_float3_new_max() TestUtils.AreEqual(new float3(1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_min() { var aabb = new MinMaxAABB(); @@ -36,7 +36,7 @@ public static void Encapsulate_float3_new_min() TestUtils.AreEqual(new float3(-1.0f), aabb.Min); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_minx_maxyz() { var aabb = new MinMaxAABB(); @@ -45,7 +45,7 @@ public static void Encapsulate_float3_new_minx_maxyz() TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_minxy_maxz() { var aabb = new MinMaxAABB(); @@ -54,7 +54,7 @@ public static void Encapsulate_float3_new_minxy_maxz() TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_minxz_maxy() { var aabb = new MinMaxAABB(); @@ -63,7 +63,7 @@ public static void Encapsulate_float3_new_minxz_maxy() TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_minz_maxxy() { var aabb = new MinMaxAABB(); @@ -72,7 +72,7 @@ public static void Encapsulate_float3_new_minz_maxxy() TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_float3_new_miny_maxxz() { var aabb = new MinMaxAABB(); @@ -81,7 +81,7 @@ public static void Encapsulate_float3_new_miny_maxxz() TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_trivial() { var aabb = new MinMaxAABB(); @@ -90,7 +90,7 @@ public static void Encapsulate_MinMaxAABB_trivial() TestUtils.AreEqual(float3.zero, aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_max() { var aabb = new MinMaxAABB(); @@ -100,7 +100,7 @@ public static void Encapsulate_MinMaxAABB_new_max() TestUtils.AreEqual(p, aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_min() { var aabb = new MinMaxAABB(); @@ -110,7 +110,7 @@ public static void Encapsulate_MinMaxAABB_new_min() TestUtils.AreEqual(p, aabb.Min); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_minx_maxyz() { var aabb = new MinMaxAABB(); @@ -119,7 +119,7 @@ public static void Encapsulate_MinMaxAABB_new_minx_maxyz() TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_minxy_maxz() { var aabb = new MinMaxAABB(); @@ -128,7 +128,7 @@ public static void Encapsulate_MinMaxAABB_new_minxy_maxz() TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_minxz_maxy() { var aabb = new MinMaxAABB(); @@ -137,7 +137,7 @@ public static void Encapsulate_MinMaxAABB_new_minxz_maxy() TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_minz_maxxy() { var aabb = new MinMaxAABB(); @@ -146,7 +146,7 @@ public static void Encapsulate_MinMaxAABB_new_minz_maxxy() TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Encapsulate_MinMaxAABB_new_miny_maxxz() { var aabb = new MinMaxAABB(); @@ -155,14 +155,14 @@ public static void Encapsulate_MinMaxAABB_new_miny_maxxz() TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_trivial() { MinMaxAABB aabb = new MinMaxAABB(); TestUtils.IsTrue(aabb.Equals(aabb)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals() { MinMaxAABB aabb1 = new MinMaxAABB { Min = new float3(-123.0f, 0.5182f, 20.0f), Max = new float3(1.0f, -1.0f, 0.99191f) }; @@ -171,7 +171,7 @@ public static void Equals() TestUtils.IsTrue(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_diff_minx() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -180,7 +180,7 @@ public static void Equals_diff_minx() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_diff_miny() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -189,7 +189,7 @@ public static void Equals_diff_miny() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_diff_minz() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -198,7 +198,7 @@ public static void Equals_diff_minz() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_diff_maxx() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -207,7 +207,7 @@ public static void Equals_diff_maxx() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_diff_maxy() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -216,7 +216,7 @@ public static void Equals_diff_maxy() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Equals_diff_maxz() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -225,7 +225,7 @@ public static void Equals_diff_maxz() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void SurfaceArea() { var min = new float3(-47.989063262939453125f, 28.037994384765625f, -9.756519317626953125f); @@ -235,7 +235,7 @@ public static void SurfaceArea() TestUtils.AreEqual(14400.470703125f, aabb.SurfaceArea, 1, true); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Extents() { var min = new float3(48.152984619140625f, -33.58978271484375f, -37.498805999755859375f); @@ -246,7 +246,7 @@ public static void Extents() TestUtils.AreEqual(expected, aabb.Extents); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Center() { var min = new float3(47.902675628662109375f, -34.302494049072265625f, 22.7147884368896484375f); @@ -257,7 +257,7 @@ public static void Center() TestUtils.AreEqual(expected, aabb.Center); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void HalfExtents() { var min = new float3(-14.3485383987426757813f, 28.68161773681640625f, -40.28060150146484375f); @@ -268,7 +268,7 @@ public static void HalfExtents() TestUtils.AreEqual(expected, aabb.HalfExtents); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Constructor() { var min = new float3(38.95940399169921875f, -24.644245147705078125f, 27.7903194427490234375f); @@ -279,7 +279,7 @@ public static void Constructor() TestUtils.AreEqual(max, aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ContainsPoint() { var aabb = new MinMaxAABB(new float3(-1), new float3(1)); @@ -301,7 +301,7 @@ public static void ContainsPoint() TestUtils.IsFalse(aabb.Contains(new float3(-1.0f, -1.0f, -1.0f - EPSILON))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ContainsAabb_Trivial() { var aabb1 = new MinMaxAABB(); @@ -311,7 +311,7 @@ public static void ContainsAabb_Trivial() TestUtils.IsTrue(aabb2.Contains(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ContainsAabb() { var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -321,7 +321,7 @@ public static void ContainsAabb() TestUtils.IsFalse(aabb2.Contains(aabb1)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ContainsAabb_BarelyNotContained() { var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -340,7 +340,7 @@ public static void ContainsAabb_BarelyNotContained() TestUtils.IsFalse(aabb1.Contains(aabb7)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Overlap_Trivial() { var aabb = new MinMaxAABB(); @@ -348,7 +348,7 @@ public static void Overlap_Trivial() TestUtils.IsTrue(aabb.Overlaps(aabb)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Overlap_Corner() { var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -389,7 +389,7 @@ public static void Overlap_Corner() TestUtils.IsTrue(cornerAabb8.Overlaps(aabb)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void NoOverlap_Corner() { var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -430,7 +430,7 @@ public static void NoOverlap_Corner() TestUtils.IsFalse(cornerAabb8.Overlaps(aabb)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Expand_PositiveDistance() { var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f)); @@ -440,7 +440,7 @@ public static void Expand_PositiveDistance() TestUtils.AreEqual(new float3(1.5f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Expand_NegativeDistance() { var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f)); @@ -450,7 +450,7 @@ public static void Expand_NegativeDistance() TestUtils.AreEqual(new float3(-0.5f), aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CreateFromCenterAndExtents() { var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f); @@ -463,7 +463,7 @@ public static void CreateFromCenterAndExtents() TestUtils.AreEqual(expectedMax, aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CreateFromCenterAndHalfExtents() { var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f); @@ -476,14 +476,14 @@ public static void CreateFromCenterAndHalfExtents() TestUtils.AreEqual(expectedMax, aabb.Max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void IsValid_Trivial() { TestUtils.IsTrue(new MinMaxAABB().IsValid); TestUtils.IsFalse(new MinMaxAABB(new float3(1.0f), new float3(-1.0f)).IsValid); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void IsValid_OneComponentInvalid() { TestUtils.IsFalse(new MinMaxAABB(float3.zero, new float3(-1.0f, 0.0f, 0.0f)).IsValid); @@ -494,7 +494,7 @@ public static void IsValid_OneComponentInvalid() TestUtils.IsFalse(new MinMaxAABB(new float3(0.0f, 0.0f, 1.0f), float3.zero).IsValid); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Transform_RigidTransform() { var t = new RigidTransform(quaternion.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f)); @@ -507,7 +507,7 @@ public static void Transform_RigidTransform() TestUtils.AreEqual(expectedMax, aabb.Max, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Transform_float4x4() { var t = new float4x4(float3x3.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f)); @@ -520,7 +520,7 @@ public static void Transform_float4x4() TestUtils.AreEqual(expectedMax, aabb.Max, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Transform_float3x3() { var t = float3x3.EulerXYZ(PI * 0.25f); diff --git a/src/Tests/Tests/Shared/TestPlane.cs b/src/Tests/Tests/Shared/TestPlane.cs index 91e60044..c79ecb0b 100644 --- a/src/Tests/Tests/Shared/TestPlane.cs +++ b/src/Tests/Tests/Shared/TestPlane.cs @@ -10,7 +10,7 @@ public class TestPlane // An arbitrary tolerance. const float Tolerance = 0.0000025f; - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Empty() { var p = new Plane(); @@ -20,7 +20,7 @@ public static void Empty() TestUtils.AreEqual(0.0f, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void GetNormal() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -28,7 +28,7 @@ public static void GetNormal() TestUtils.AreEqual(new float3(1.0f, 2.0f, 3.0f), p.Normal); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void GetDistance() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -36,7 +36,7 @@ public static void GetDistance() TestUtils.AreEqual(4.0f, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void SetNormal() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -45,7 +45,7 @@ public static void SetNormal() TestUtils.AreEqual(new float3(-1.0f, -2.0f, -3.0f), p.Normal); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void SetDistance() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -54,7 +54,7 @@ public static void SetDistance() TestUtils.AreEqual(-4.0f, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithNormalAndDistance() { var n = math.normalize(new float3(4.0f, -5.0f, 6.0f)); @@ -66,7 +66,7 @@ public static void ConstructWithNormalAndDistance() TestUtils.AreEqual(d, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithCoefficients_NonUnitLengthNormal() { var abcd = new float4(4.0f, -5.0f, 6.0f, 123.0f); @@ -78,7 +78,7 @@ public static void ConstructWithCoefficients_NonUnitLengthNormal() TestUtils.AreEqual(expected.w, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithNormalAndPointInPlane_NegativeDistance() { var n = math.up(); @@ -90,7 +90,7 @@ public static void ConstructWithNormalAndPointInPlane_NegativeDistance() TestUtils.AreEqual(-1.0f, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithNormalAndPointInPlane_PositiveDistance() { var n = math.down(); @@ -102,7 +102,7 @@ public static void ConstructWithNormalAndPointInPlane_PositiveDistance() TestUtils.AreEqual(1.0f, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithNormalAndPointInPlane() { var normal = new float3(2.0f, 2.0f, 2.0f); @@ -116,7 +116,7 @@ public static void ConstructWithNormalAndPointInPlane() TestUtils.AreEqual(expectedD, p.Distance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithTwoVectorsAndOrigin_Trivial() { var v1 = new float3(1.0f, 0.0f, 0.0f); @@ -126,7 +126,7 @@ public static void ConstructWithTwoVectorsAndOrigin_Trivial() TestUtils.AreEqual(new float4(0.0f, 0.0f, 1.0f, 0.0f), p); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin() { var v1 = new float3(5.0f, 0.0f, 0.0f); @@ -136,7 +136,7 @@ public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin() TestUtils.AreEqual(new float4(0.0f, 0.0f, -1.0f, 1.0f), p); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void SignedDistanceToPoint() { var vInPlane1 = new float3(2.0f, 1.0f, -0.18f); @@ -152,7 +152,7 @@ public static void SignedDistanceToPoint() TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(pointInPlane - n), Tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void SignedDistanceToPointTrivial() { var p = new Plane(math.up(), 0.0f); @@ -174,7 +174,7 @@ public static void SignedDistanceToPointTrivial() TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(math.down() + math.forward())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ProjectionTrivial() { var p = new Plane(math.up(), 0.0f); @@ -183,7 +183,7 @@ public static void ProjectionTrivial() TestUtils.AreEqual(expected, p.Projection(math.up() + expected)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Projection() { var normal = new float3(1.0f); @@ -195,7 +195,7 @@ public static void Projection() TestUtils.AreEqual(expected, p.Projection(expected), math.EPSILON); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void Flipped() { var normal = new float3(1.0f); @@ -207,7 +207,7 @@ public static void Flipped() TestUtils.AreEqual(new float4(expectedN, expectedD), p.Flipped, Tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void ImplicitToFloat4() { var normal = new float3(1.1f, -20.0f, 15.182f); @@ -220,7 +220,7 @@ public static void ImplicitToFloat4() TestUtils.AreEqual(new float4(expectedN, expectedD), p_as_float4, Tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void NormalizeFloat4() { var p = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f); @@ -229,7 +229,7 @@ public static void NormalizeFloat4() TestUtils.AreEqual(expected, Plane.Normalize(p), Tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void NormalizePlane() { var p = new Plane { NormalAndDistance = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f) }; @@ -241,7 +241,7 @@ public static void NormalizePlane() TestUtils.AreEqual(expected.w, normalized.Distance, Tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CreateFromUnitNormalAndDistance() { var n = new float3(9.108767140247756e-02f, 3.966831912609620e-01f, 9.134251375397404e-01f); @@ -252,7 +252,7 @@ public static void CreateFromUnitNormalAndDistance() TestUtils.AreEqual(expected, p.NormalAndDistance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CreateFromUnitNormalAndPointInPlane() { var n = new float3(4.724920516359185e-01f, 1.444614284194820e-01f, 8.694148358751899e-01f); diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs index 301725ee..0279de90 100644 --- a/src/Tests/Tests/Shared/TestQuaternion.cs +++ b/src/Tests/Tests/Shared/TestQuaternion.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestQuaternion { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_basic_constructors() { quaternion q = quaternion(1.0f, 2.0f, 3.0f, 4.0f); @@ -23,7 +23,7 @@ public static void quaternion_basic_constructors() TestUtils.AreEqual(4.0f, q2.value.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_construct_from_matrix() { TestUtils.AreEqual(float3x3(quaternion(TestMatrix.test3x3_xyz)), TestMatrix.test3x3_xyz, 0.0001f); @@ -45,7 +45,7 @@ public static void quaternion_construct_from_matrix() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_construct_from_matrix3x3_torture() { Random rnd = new Random(0x12345678); @@ -58,7 +58,7 @@ public static void quaternion_construct_from_matrix3x3_torture() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_construct_from_matrix4x4_torture() { Random rnd = new Random(0x12345678); @@ -71,7 +71,7 @@ public static void quaternion_construct_from_matrix4x4_torture() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_axis_angle() { quaternion q = quaternion.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f); @@ -80,7 +80,7 @@ public static void quaternion_axis_angle() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_axis_angle_consistency() { TestUtils.AreEqual(quaternion.RotateX(1.0f), quaternion.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f); @@ -88,7 +88,7 @@ public static void quaternion_axis_angle_consistency() TestUtils.AreEqual(quaternion.RotateZ(1.0f), quaternion.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void euler_to_quaternion() { float3 test_angles = TestMatrix.test_angles; @@ -158,7 +158,7 @@ public static void euler_to_quaternion() TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotateX() { float angle = 2.3f; @@ -168,7 +168,7 @@ public static void quaternion_rotateX() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotateY() { float angle = 2.3f; @@ -178,7 +178,7 @@ public static void quaternion_rotateY() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotateZ() { float angle = 2.3f; @@ -193,7 +193,7 @@ public static void quaternion_rotateZ() static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f); static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f); - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_conjugate() { quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f); @@ -203,7 +203,7 @@ public static void quaternion_conjugate() TestUtils.AreEqual(r, cq); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_inverse() { quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f); @@ -213,7 +213,7 @@ public static void quaternion_inverse() TestUtils.AreEqual(quaternion.identity, qiq, 0.00001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_dot() { float dot01 = dot(test_q0, test_q1); @@ -223,7 +223,7 @@ public static void quaternion_dot() TestUtils.AreEqual(-0.5795583f, dot02, 0.00001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_nlerp() { quaternion r0 = nlerp(test_q0, test_q1, 0.3f); @@ -235,7 +235,7 @@ public static void quaternion_nlerp() TestUtils.AreEqual(quaternion(-0.4054004f, 0.06570576f, -0.7457358f, -0.5246059f), r2, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_slerp() { quaternion r0 = slerp(test_q0, test_q1, 0.3f); @@ -247,7 +247,7 @@ public static void quaternion_slerp() TestUtils.AreEqual(quaternion(0.2596942f, -0.4369303f, 0.7902023f, 0.34239f), r2, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_mul_vector() { float3x3 m = TestMatrix.test3x3_xyz; @@ -261,7 +261,7 @@ public static void quaternion_mul_vector() TestUtils.AreEqual(mvector, qvector, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_log_exp_identity() { quaternion q = quaternion(1.2f, -2.6f, 3.1f, 6.0f); @@ -270,7 +270,7 @@ public static void quaternion_log_exp_identity() TestUtils.AreEqual(q, exp_log_q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_log_exp_rotation() { quaternion q = quaternion(TestMatrix.test3x3_xyz); @@ -280,7 +280,7 @@ public static void quaternion_log_exp_rotation() TestUtils.AreEqual(q3, t, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_unitlog_unitexp_rotation() { quaternion q = quaternion(TestMatrix.test3x3_xyz); @@ -290,7 +290,7 @@ public static void quaternion_unitlog_unitexp_rotation() TestUtils.AreEqual(q3, t, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_look_rotation() { // Exercise the 4 cases @@ -319,7 +319,7 @@ public static void quaternion_look_rotation() TestUtils.AreEqual(float3x3.LookRotation(forward3, up3), float3x3(q3), 0.001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_look_rotation_safe() { float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f; @@ -381,7 +381,7 @@ public static void quaternion_angle() TestUtils.AreEqual(0f, angle); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_identity() { const float tolerance = 1e-5f; @@ -389,7 +389,7 @@ public static void quaternion_rotation_from_3x3_identity() TestUtils.AreEqual(quaternion.identity, q, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_with_uniform_scale() { const float tolerance = 1e-5f; @@ -401,7 +401,7 @@ public static void quaternion_rotation_from_3x3_with_uniform_scale() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_with_nonuniform_scale() { const float tolerance = 1e-5f; @@ -413,7 +413,7 @@ public static void quaternion_rotation_from_3x3_with_nonuniform_scale() TestUtils.AreEqual(quaternion.identity, q, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_with_negative_scale_x() { const float tolerance = 1e-5f; @@ -425,7 +425,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_x() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_with_negative_scale_y() { const float tolerance = 1e-5f; @@ -437,7 +437,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_y() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_with_negative_scale_z() { const float tolerance = 1e-5f; @@ -449,7 +449,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_z() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale() { const float tolerance = 1e-5f; diff --git a/src/Tests/Tests/Shared/TestRigidTransform.cs b/src/Tests/Tests/Shared/TestRigidTransform.cs index ac0d8060..eacec9ed 100644 --- a/src/Tests/Tests/Shared/TestRigidTransform.cs +++ b/src/Tests/Tests/Shared/TestRigidTransform.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestRigidTransform { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_construct_from_matrix() { float4x4 m4x4 = TestMatrix.test4x4_zyx; @@ -19,7 +19,7 @@ public static void rigid_transform_construct_from_matrix() TestUtils.AreEqual(m4x4, mq4x4, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_axisAngle() { RigidTransform q = RigidTransform.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f); @@ -28,7 +28,7 @@ public static void rigid_transform_axisAngle() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_euler() { float3 test_angles = TestMatrix.test_angles; @@ -98,7 +98,7 @@ public static void rigid_transform_euler() TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_rotateX() { float angle = 2.3f; @@ -108,7 +108,7 @@ public static void rigid_transform_rotateX() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_rotateY() { float angle = 2.3f; @@ -118,7 +118,7 @@ public static void rigid_transform_rotateY() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_rotateZ() { float angle = 2.3f; @@ -133,7 +133,7 @@ public static void rigid_transform_rotateZ() static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f); static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f); - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_inverse() { RigidTransform q = RigidTransform(quaternion(1.0f, -2.0f, 3.0f, -4.0f), float3(1,2,3)); @@ -143,7 +143,7 @@ public static void rigid_transform_inverse() TestUtils.AreEqual(RigidTransform.identity, qiq, 0.00001f); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void rigid_transform_mul_vector() { float4x4 m = TestMatrix.test4x4_xyz; diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs index f5ae195c..db889bd9 100644 --- a/src/Tests/Tests/Shared/TestSvd.cs +++ b/src/Tests/Tests/Shared/TestSvd.cs @@ -48,7 +48,7 @@ static void ValidatePenrose2(in float3x3 a, in float3x3 b) static void ValidateSingular(in float3x3 a) => TestUtils.AreEqual(0.0f, math.determinant(a), k_SVDTolerance); - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanSVDInverseNonSingularFloat3x3() { var mat = math.float3x3( @@ -71,7 +71,7 @@ public static void CanSVDInverseNonSingularFloat3x3() TestUtils.AreEqual(1f, testIdentity.c2.z, k_SVDTolerance); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanSVDInverseFloat3x3With_NullColumn() { var mat = math.float3x3( @@ -89,7 +89,7 @@ public static void CanSVDInverseFloat3x3With_NullColumn() ValidatePenrose2(inv, mat); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanSVDInverseFloat3x3With_NullRow() { var mat = math.float3x3( @@ -107,7 +107,7 @@ public static void CanSVDInverseFloat3x3With_NullRow() ValidatePenrose2(inv, mat); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanSVDInverseFloat3x3With_LinearDependentColumn() { var mat = math.float3x3( @@ -125,7 +125,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentColumn() ValidatePenrose2(inv, mat); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanSVDInverseFloat3x3With_LinearDependentRow() { var mat = math.float3x3( @@ -143,7 +143,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentRow() ValidatePenrose2(inv, mat); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanSVDInverseFloat3x3With_RotatedZeroScale() { var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f))); @@ -160,7 +160,7 @@ public static void CanSVDInverseFloat3x3With_RotatedZeroScale() } // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181() { var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f)); @@ -170,7 +170,7 @@ public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181() } // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY() { var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)); diff --git a/src/Tests/Tests/Shared/TestUint2.gen.cs b/src/Tests/Tests/Shared/TestUint2.gen.cs index 67c0813b..04620a33 100644 --- a/src/Tests/Tests/Shared/TestUint2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_zero() { TestUtils.AreEqual(0u, uint2.zero.x); TestUtils.AreEqual(0u, uint2.zero.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_constructor() { uint2 a = new uint2(1, 2); @@ -30,7 +30,7 @@ public static void uint2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_scalar_constructor() { uint2 a = new uint2(17u); @@ -38,7 +38,7 @@ public static void uint2_scalar_constructor() TestUtils.AreEqual(17u, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_static_constructor() { uint2 a = uint2(1, 2); @@ -46,7 +46,7 @@ public static void uint2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_static_scalar_constructor() { uint2 a = uint2(17u); @@ -54,7 +54,7 @@ public static void uint2_static_scalar_constructor() TestUtils.AreEqual(17u, a.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_equal_wide_wide() { uint2 a0 = uint2(2105871082, 35218899); @@ -78,7 +78,7 @@ public static void uint2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_equal_wide_scalar() { uint2 a0 = uint2(437822262, 2020661134); @@ -102,7 +102,7 @@ public static void uint2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -126,7 +126,7 @@ public static void uint2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_not_equal_wide_wide() { uint2 a0 = uint2(1977284100, 1293292704); @@ -150,7 +150,7 @@ public static void uint2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_not_equal_wide_scalar() { uint2 a0 = uint2(1038269360, 1427812625); @@ -174,7 +174,7 @@ public static void uint2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -198,7 +198,7 @@ public static void uint2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_less_wide_wide() { uint2 a0 = uint2(1486550609, 1779244308); @@ -222,7 +222,7 @@ public static void uint2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_less_wide_scalar() { uint2 a0 = uint2(796797557, 670113454); @@ -246,7 +246,7 @@ public static void uint2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -270,7 +270,7 @@ public static void uint2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_greater_wide_wide() { uint2 a0 = uint2(2087717754, 1725569452); @@ -294,7 +294,7 @@ public static void uint2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_greater_wide_scalar() { uint2 a0 = uint2(1208626274, 239697208); @@ -318,7 +318,7 @@ public static void uint2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -342,7 +342,7 @@ public static void uint2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_less_equal_wide_wide() { uint2 a0 = uint2(154092149, 1515170149); @@ -366,7 +366,7 @@ public static void uint2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_less_equal_wide_scalar() { uint2 a0 = uint2(1479531977, 1427983411); @@ -390,7 +390,7 @@ public static void uint2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -414,7 +414,7 @@ public static void uint2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_greater_equal_wide_wide() { uint2 a0 = uint2(8538378, 2131749726); @@ -438,7 +438,7 @@ public static void uint2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_greater_equal_wide_scalar() { uint2 a0 = uint2(2049236663, 182691143); @@ -462,7 +462,7 @@ public static void uint2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -486,7 +486,7 @@ public static void uint2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_add_wide_wide() { uint2 a0 = uint2(2135171378, 21433296); @@ -510,7 +510,7 @@ public static void uint2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_add_wide_scalar() { uint2 a0 = uint2(665815972, 1783729250); @@ -534,7 +534,7 @@ public static void uint2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -558,7 +558,7 @@ public static void uint2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_sub_wide_wide() { uint2 a0 = uint2(1410318491, 1097280168); @@ -582,7 +582,7 @@ public static void uint2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_sub_wide_scalar() { uint2 a0 = uint2(1508669340, 1594795463); @@ -606,7 +606,7 @@ public static void uint2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -630,7 +630,7 @@ public static void uint2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_mul_wide_wide() { uint2 a0 = uint2(61417577, 219585476); @@ -654,7 +654,7 @@ public static void uint2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_mul_wide_scalar() { uint2 a0 = uint2(871746615, 492532311); @@ -678,7 +678,7 @@ public static void uint2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -702,7 +702,7 @@ public static void uint2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_div_wide_wide() { uint2 a0 = uint2(333171510, 858154903); @@ -726,7 +726,7 @@ public static void uint2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_div_wide_scalar() { uint2 a0 = uint2(1433072926, 1073958635); @@ -750,7 +750,7 @@ public static void uint2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -774,7 +774,7 @@ public static void uint2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_mod_wide_wide() { uint2 a0 = uint2(258342924, 1454754891); @@ -798,7 +798,7 @@ public static void uint2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_mod_wide_scalar() { uint2 a0 = uint2(560988938, 629524514); @@ -822,7 +822,7 @@ public static void uint2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -846,7 +846,7 @@ public static void uint2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_plus() { uint2 a0 = uint2(195392567, 222719748); @@ -866,7 +866,7 @@ public static void uint2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_neg() { uint2 a0 = uint2(1385088677, 94114564); @@ -886,7 +886,7 @@ public static void uint2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_prefix_inc() { uint2 a0 = uint2(780471723, 954741756); @@ -906,7 +906,7 @@ public static void uint2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_postfix_inc() { uint2 a0 = uint2(241865086, 2145821641); @@ -926,7 +926,7 @@ public static void uint2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_prefix_dec() { uint2 a0 = uint2(1331961415, 1612382200); @@ -946,7 +946,7 @@ public static void uint2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_postfix_dec() { uint2 a0 = uint2(1870005937, 1708534798); @@ -966,7 +966,7 @@ public static void uint2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_and_wide_wide() { uint2 a0 = uint2(1055241304, 859321394); @@ -990,7 +990,7 @@ public static void uint2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_and_wide_scalar() { uint2 a0 = uint2(1513158868, 284695609); @@ -1014,7 +1014,7 @@ public static void uint2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1038,7 +1038,7 @@ public static void uint2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_or_wide_wide() { uint2 a0 = uint2(1920951869, 1750772852); @@ -1062,7 +1062,7 @@ public static void uint2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_or_wide_scalar() { uint2 a0 = uint2(1295304853, 1307252624); @@ -1086,7 +1086,7 @@ public static void uint2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1110,7 +1110,7 @@ public static void uint2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_xor_wide_wide() { uint2 a0 = uint2(1843655608, 362425681); @@ -1134,7 +1134,7 @@ public static void uint2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_xor_wide_scalar() { uint2 a0 = uint2(169345668, 176087064); @@ -1158,7 +1158,7 @@ public static void uint2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1182,7 +1182,7 @@ public static void uint2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_left_shift() { uint2 a0 = uint2(1129100049, 829482269); @@ -1206,7 +1206,7 @@ public static void uint2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_right_shift() { uint2 a0 = uint2(809126085, 908563670); @@ -1230,7 +1230,7 @@ public static void uint2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_operator_bitwise_not() { uint2 a0 = uint2(111796841, 603562399); @@ -1250,7 +1250,7 @@ public static void uint2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_shuffle_result_1() { uint2 a = uint2(0, 1); @@ -1262,7 +1262,7 @@ public static void uint2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_shuffle_result_2() { uint2 a = uint2(0, 1); @@ -1286,7 +1286,7 @@ public static void uint2_shuffle_result_2() TestUtils.AreEqual(uint2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_shuffle_result_3() { uint2 a = uint2(0, 1); @@ -1310,7 +1310,7 @@ public static void uint2_shuffle_result_3() TestUtils.AreEqual(uint3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_shuffle_result_4() { uint2 a = uint2(0, 1); @@ -1334,7 +1334,7 @@ public static void uint2_shuffle_result_4() TestUtils.AreEqual(uint4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX)); } - [TestCase] + [TestCase /* For player builds */] public static void uint2_EqualsObjectOverride() { TestUtils.IsFalse(new uint2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint2x2.gen.cs b/src/Tests/Tests/Shared/TestUint2x2.gen.cs index a5f371ec..dd8ed7a4 100644 --- a/src/Tests/Tests/Shared/TestUint2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_zero() { TestUtils.AreEqual(0u, uint2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void uint2x2_zero() TestUtils.AreEqual(0u, uint2x2.zero.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_identity() { TestUtils.AreEqual(1u, uint2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void uint2x2_identity() TestUtils.AreEqual(1u, uint2x2.identity.c1.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_equal_wide_wide() { uint2x2 a0 = uint2x2(2105871082, 35218899, 1550755093, 764676020); @@ -57,7 +57,7 @@ public static void uint2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_equal_wide_scalar() { uint2x2 a0 = uint2x2(437822262, 2020661134, 541786900, 853113810); @@ -81,7 +81,7 @@ public static void uint2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -105,7 +105,7 @@ public static void uint2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_not_equal_wide_wide() { uint2x2 a0 = uint2x2(1977284100, 1293292704, 1547283851, 422428953); @@ -129,7 +129,7 @@ public static void uint2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_not_equal_wide_scalar() { uint2x2 a0 = uint2x2(1038269360, 1427812625, 103361237, 1347017023); @@ -153,7 +153,7 @@ public static void uint2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -177,7 +177,7 @@ public static void uint2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_less_wide_wide() { uint2x2 a0 = uint2x2(1486550609, 1779244308, 1602148045, 1614085440); @@ -201,7 +201,7 @@ public static void uint2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_less_wide_scalar() { uint2x2 a0 = uint2x2(796797557, 670113454, 933579492, 278884514); @@ -225,7 +225,7 @@ public static void uint2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -249,7 +249,7 @@ public static void uint2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_greater_wide_wide() { uint2x2 a0 = uint2x2(2087717754, 1725569452, 1298066182, 1693943616); @@ -273,7 +273,7 @@ public static void uint2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_greater_wide_scalar() { uint2x2 a0 = uint2x2(1208626274, 239697208, 1979453345, 1253474001); @@ -297,7 +297,7 @@ public static void uint2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -321,7 +321,7 @@ public static void uint2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_less_equal_wide_wide() { uint2x2 a0 = uint2x2(154092149, 1515170149, 1083970332, 785807178); @@ -345,7 +345,7 @@ public static void uint2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_less_equal_wide_scalar() { uint2x2 a0 = uint2x2(1479531977, 1427983411, 415250630, 1245345407); @@ -369,7 +369,7 @@ public static void uint2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -393,7 +393,7 @@ public static void uint2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_greater_equal_wide_wide() { uint2x2 a0 = uint2x2(8538378, 2131749726, 265427108, 523609761); @@ -417,7 +417,7 @@ public static void uint2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_greater_equal_wide_scalar() { uint2x2 a0 = uint2x2(2049236663, 182691143, 634973382, 1197012109); @@ -441,7 +441,7 @@ public static void uint2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -465,7 +465,7 @@ public static void uint2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_add_wide_wide() { uint2x2 a0 = uint2x2(2135171378, 21433296, 1954723494, 683604307); @@ -489,7 +489,7 @@ public static void uint2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_add_wide_scalar() { uint2x2 a0 = uint2x2(665815972, 1783729250, 1591678394, 1284528538); @@ -513,7 +513,7 @@ public static void uint2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -537,7 +537,7 @@ public static void uint2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_sub_wide_wide() { uint2x2 a0 = uint2x2(1410318491, 1097280168, 1827039044, 28881338); @@ -561,7 +561,7 @@ public static void uint2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_sub_wide_scalar() { uint2x2 a0 = uint2x2(1508669340, 1594795463, 266707545, 643102647); @@ -585,7 +585,7 @@ public static void uint2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -609,7 +609,7 @@ public static void uint2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_mul_wide_wide() { uint2x2 a0 = uint2x2(61417577, 219585476, 1362520891, 1511084277); @@ -633,7 +633,7 @@ public static void uint2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_mul_wide_scalar() { uint2x2 a0 = uint2x2(871746615, 492532311, 570557670, 2142306629); @@ -657,7 +657,7 @@ public static void uint2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -681,7 +681,7 @@ public static void uint2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_div_wide_wide() { uint2x2 a0 = uint2x2(333171510, 858154903, 1181365836, 671357749); @@ -705,7 +705,7 @@ public static void uint2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_div_wide_scalar() { uint2x2 a0 = uint2x2(1433072926, 1073958635, 1195142312, 536596719); @@ -729,7 +729,7 @@ public static void uint2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -753,7 +753,7 @@ public static void uint2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_mod_wide_wide() { uint2x2 a0 = uint2x2(258342924, 1454754891, 723352342, 1981431473); @@ -777,7 +777,7 @@ public static void uint2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_mod_wide_scalar() { uint2x2 a0 = uint2x2(560988938, 629524514, 767711194, 434281967); @@ -801,7 +801,7 @@ public static void uint2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -825,7 +825,7 @@ public static void uint2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_plus() { uint2x2 a0 = uint2x2(195392567, 222719748, 1002351013, 1570765263); @@ -845,7 +845,7 @@ public static void uint2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_neg() { uint2x2 a0 = uint2x2(1385088677, 94114564, 1350664872, 1458616659); @@ -865,7 +865,7 @@ public static void uint2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_prefix_inc() { uint2x2 a0 = uint2x2(780471723, 954741756, 272723451, 2142862245); @@ -885,7 +885,7 @@ public static void uint2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_postfix_inc() { uint2x2 a0 = uint2x2(241865086, 2145821641, 1596166022, 803592338); @@ -905,7 +905,7 @@ public static void uint2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_prefix_dec() { uint2x2 a0 = uint2x2(1331961415, 1612382200, 1401591249, 2042075388); @@ -925,7 +925,7 @@ public static void uint2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_postfix_dec() { uint2x2 a0 = uint2x2(1870005937, 1708534798, 704493460, 462940703); @@ -945,7 +945,7 @@ public static void uint2x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_and_wide_wide() { uint2x2 a0 = uint2x2(1055241304, 859321394, 1088358961, 2090949513); @@ -969,7 +969,7 @@ public static void uint2x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_and_wide_scalar() { uint2x2 a0 = uint2x2(1513158868, 284695609, 734595037, 1566510707); @@ -993,7 +993,7 @@ public static void uint2x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1017,7 +1017,7 @@ public static void uint2x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_or_wide_wide() { uint2x2 a0 = uint2x2(1920951869, 1750772852, 1420019191, 732977093); @@ -1041,7 +1041,7 @@ public static void uint2x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_or_wide_scalar() { uint2x2 a0 = uint2x2(1295304853, 1307252624, 350194630, 1128063578); @@ -1065,7 +1065,7 @@ public static void uint2x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1089,7 +1089,7 @@ public static void uint2x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_xor_wide_wide() { uint2x2 a0 = uint2x2(1843655608, 362425681, 640805534, 1342040268); @@ -1113,7 +1113,7 @@ public static void uint2x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_xor_wide_scalar() { uint2x2 a0 = uint2x2(169345668, 176087064, 2084362901, 1663924004); @@ -1137,7 +1137,7 @@ public static void uint2x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1161,7 +1161,7 @@ public static void uint2x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_left_shift() { uint2x2 a0 = uint2x2(1129100049, 829482269, 1571297368, 443753193); @@ -1185,7 +1185,7 @@ public static void uint2x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_right_shift() { uint2x2 a0 = uint2x2(809126085, 908563670, 763568837, 1986717290); @@ -1209,7 +1209,7 @@ public static void uint2x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x2_operator_bitwise_not() { uint2x2 a0 = uint2x2(111796841, 603562399, 745091931, 853183268); @@ -1229,7 +1229,7 @@ public static void uint2x2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint2x2_EqualsObjectOverride() { TestUtils.IsFalse(new uint2x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint2x3.gen.cs b/src/Tests/Tests/Shared/TestUint2x3.gen.cs index d8aa9b0a..0dcca69a 100644 --- a/src/Tests/Tests/Shared/TestUint2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_zero() { TestUtils.AreEqual(0u, uint2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void uint2x3_zero() TestUtils.AreEqual(0u, uint2x3.zero.c2.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_equal_wide_wide() { uint2x3 a0 = uint2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void uint2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_equal_wide_scalar() { uint2x3 a0 = uint2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void uint2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -98,7 +98,7 @@ public static void uint2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_not_equal_wide_wide() { uint2x3 a0 = uint2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void uint2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_not_equal_wide_scalar() { uint2x3 a0 = uint2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void uint2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -170,7 +170,7 @@ public static void uint2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_less_wide_wide() { uint2x3 a0 = uint2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void uint2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_less_wide_scalar() { uint2x3 a0 = uint2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void uint2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -242,7 +242,7 @@ public static void uint2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_greater_wide_wide() { uint2x3 a0 = uint2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void uint2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_greater_wide_scalar() { uint2x3 a0 = uint2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void uint2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -314,7 +314,7 @@ public static void uint2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_less_equal_wide_wide() { uint2x3 a0 = uint2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void uint2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_less_equal_wide_scalar() { uint2x3 a0 = uint2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void uint2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -386,7 +386,7 @@ public static void uint2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_greater_equal_wide_wide() { uint2x3 a0 = uint2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void uint2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_greater_equal_wide_scalar() { uint2x3 a0 = uint2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void uint2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -458,7 +458,7 @@ public static void uint2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_add_wide_wide() { uint2x3 a0 = uint2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void uint2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_add_wide_scalar() { uint2x3 a0 = uint2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void uint2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -530,7 +530,7 @@ public static void uint2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_sub_wide_wide() { uint2x3 a0 = uint2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void uint2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_sub_wide_scalar() { uint2x3 a0 = uint2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void uint2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -602,7 +602,7 @@ public static void uint2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_mul_wide_wide() { uint2x3 a0 = uint2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void uint2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_mul_wide_scalar() { uint2x3 a0 = uint2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void uint2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -674,7 +674,7 @@ public static void uint2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_div_wide_wide() { uint2x3 a0 = uint2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void uint2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_div_wide_scalar() { uint2x3 a0 = uint2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void uint2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -746,7 +746,7 @@ public static void uint2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_mod_wide_wide() { uint2x3 a0 = uint2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void uint2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_mod_wide_scalar() { uint2x3 a0 = uint2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void uint2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -818,7 +818,7 @@ public static void uint2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_plus() { uint2x3 a0 = uint2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void uint2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_neg() { uint2x3 a0 = uint2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void uint2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_prefix_inc() { uint2x3 a0 = uint2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void uint2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_postfix_inc() { uint2x3 a0 = uint2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void uint2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_prefix_dec() { uint2x3 a0 = uint2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void uint2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_postfix_dec() { uint2x3 a0 = uint2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void uint2x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_and_wide_wide() { uint2x3 a0 = uint2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void uint2x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_and_wide_scalar() { uint2x3 a0 = uint2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void uint2x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void uint2x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_or_wide_wide() { uint2x3 a0 = uint2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void uint2x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_or_wide_scalar() { uint2x3 a0 = uint2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void uint2x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void uint2x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_xor_wide_wide() { uint2x3 a0 = uint2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void uint2x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_xor_wide_scalar() { uint2x3 a0 = uint2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void uint2x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void uint2x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_left_shift() { uint2x3 a0 = uint2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void uint2x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_right_shift() { uint2x3 a0 = uint2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void uint2x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x3_operator_bitwise_not() { uint2x3 a0 = uint2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); @@ -1222,7 +1222,7 @@ public static void uint2x3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint2x3_EqualsObjectOverride() { TestUtils.IsFalse(new uint2x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint2x4.gen.cs b/src/Tests/Tests/Shared/TestUint2x4.gen.cs index 7783684e..645d9554 100644 --- a/src/Tests/Tests/Shared/TestUint2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_zero() { TestUtils.AreEqual(0u, uint2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void uint2x4_zero() TestUtils.AreEqual(0u, uint2x4.zero.c3.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_equal_wide_wide() { uint2x4 a0 = uint2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void uint2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_equal_wide_scalar() { uint2x4 a0 = uint2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void uint2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -100,7 +100,7 @@ public static void uint2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_not_equal_wide_wide() { uint2x4 a0 = uint2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void uint2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_not_equal_wide_scalar() { uint2x4 a0 = uint2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void uint2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -172,7 +172,7 @@ public static void uint2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_less_wide_wide() { uint2x4 a0 = uint2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void uint2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_less_wide_scalar() { uint2x4 a0 = uint2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void uint2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -244,7 +244,7 @@ public static void uint2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_greater_wide_wide() { uint2x4 a0 = uint2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void uint2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_greater_wide_scalar() { uint2x4 a0 = uint2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void uint2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -316,7 +316,7 @@ public static void uint2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_less_equal_wide_wide() { uint2x4 a0 = uint2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void uint2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_less_equal_wide_scalar() { uint2x4 a0 = uint2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void uint2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -388,7 +388,7 @@ public static void uint2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_greater_equal_wide_wide() { uint2x4 a0 = uint2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void uint2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_greater_equal_wide_scalar() { uint2x4 a0 = uint2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void uint2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -460,7 +460,7 @@ public static void uint2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_add_wide_wide() { uint2x4 a0 = uint2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void uint2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_add_wide_scalar() { uint2x4 a0 = uint2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void uint2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -532,7 +532,7 @@ public static void uint2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_sub_wide_wide() { uint2x4 a0 = uint2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void uint2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_sub_wide_scalar() { uint2x4 a0 = uint2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void uint2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -604,7 +604,7 @@ public static void uint2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_mul_wide_wide() { uint2x4 a0 = uint2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void uint2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_mul_wide_scalar() { uint2x4 a0 = uint2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void uint2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -676,7 +676,7 @@ public static void uint2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_div_wide_wide() { uint2x4 a0 = uint2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void uint2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_div_wide_scalar() { uint2x4 a0 = uint2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void uint2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -748,7 +748,7 @@ public static void uint2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_mod_wide_wide() { uint2x4 a0 = uint2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void uint2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_mod_wide_scalar() { uint2x4 a0 = uint2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void uint2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -820,7 +820,7 @@ public static void uint2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_plus() { uint2x4 a0 = uint2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void uint2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_neg() { uint2x4 a0 = uint2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void uint2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_prefix_inc() { uint2x4 a0 = uint2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void uint2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_postfix_inc() { uint2x4 a0 = uint2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void uint2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_prefix_dec() { uint2x4 a0 = uint2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void uint2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_postfix_dec() { uint2x4 a0 = uint2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void uint2x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_and_wide_wide() { uint2x4 a0 = uint2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void uint2x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_and_wide_scalar() { uint2x4 a0 = uint2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void uint2x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void uint2x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_or_wide_wide() { uint2x4 a0 = uint2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void uint2x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_or_wide_scalar() { uint2x4 a0 = uint2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void uint2x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void uint2x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_xor_wide_wide() { uint2x4 a0 = uint2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void uint2x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_xor_wide_scalar() { uint2x4 a0 = uint2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void uint2x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void uint2x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_left_shift() { uint2x4 a0 = uint2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void uint2x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_right_shift() { uint2x4 a0 = uint2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void uint2x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2x4_operator_bitwise_not() { uint2x4 a0 = uint2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); @@ -1224,7 +1224,7 @@ public static void uint2x4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint2x4_EqualsObjectOverride() { TestUtils.IsFalse(new uint2x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint3.gen.cs b/src/Tests/Tests/Shared/TestUint3.gen.cs index 6fca57ce..67055e17 100644 --- a/src/Tests/Tests/Shared/TestUint3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_zero() { TestUtils.AreEqual(0u, uint3.zero.x); @@ -23,7 +23,7 @@ public static void uint3_zero() TestUtils.AreEqual(0u, uint3.zero.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_constructor() { uint3 a = new uint3(1, 2, 3); @@ -32,7 +32,7 @@ public static void uint3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_scalar_constructor() { uint3 a = new uint3(17u); @@ -41,7 +41,7 @@ public static void uint3_scalar_constructor() TestUtils.AreEqual(17u, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_static_constructor() { uint3 a = uint3(1, 2, 3); @@ -50,7 +50,7 @@ public static void uint3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_static_scalar_constructor() { uint3 a = uint3(17u); @@ -59,7 +59,7 @@ public static void uint3_static_scalar_constructor() TestUtils.AreEqual(17u, a.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_equal_wide_wide() { uint3 a0 = uint3(2105871082, 35218899, 1550755093); @@ -83,7 +83,7 @@ public static void uint3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_equal_wide_scalar() { uint3 a0 = uint3(437822262, 2020661134, 541786900); @@ -107,7 +107,7 @@ public static void uint3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -131,7 +131,7 @@ public static void uint3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_not_equal_wide_wide() { uint3 a0 = uint3(1977284100, 1293292704, 1547283851); @@ -155,7 +155,7 @@ public static void uint3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_not_equal_wide_scalar() { uint3 a0 = uint3(1038269360, 1427812625, 103361237); @@ -179,7 +179,7 @@ public static void uint3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -203,7 +203,7 @@ public static void uint3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_less_wide_wide() { uint3 a0 = uint3(1486550609, 1779244308, 1602148045); @@ -227,7 +227,7 @@ public static void uint3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_less_wide_scalar() { uint3 a0 = uint3(796797557, 670113454, 933579492); @@ -251,7 +251,7 @@ public static void uint3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -275,7 +275,7 @@ public static void uint3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_greater_wide_wide() { uint3 a0 = uint3(2087717754, 1725569452, 1298066182); @@ -299,7 +299,7 @@ public static void uint3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_greater_wide_scalar() { uint3 a0 = uint3(1208626274, 239697208, 1979453345); @@ -323,7 +323,7 @@ public static void uint3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -347,7 +347,7 @@ public static void uint3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_less_equal_wide_wide() { uint3 a0 = uint3(154092149, 1515170149, 1083970332); @@ -371,7 +371,7 @@ public static void uint3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_less_equal_wide_scalar() { uint3 a0 = uint3(1479531977, 1427983411, 415250630); @@ -395,7 +395,7 @@ public static void uint3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -419,7 +419,7 @@ public static void uint3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_greater_equal_wide_wide() { uint3 a0 = uint3(8538378, 2131749726, 265427108); @@ -443,7 +443,7 @@ public static void uint3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_greater_equal_wide_scalar() { uint3 a0 = uint3(2049236663, 182691143, 634973382); @@ -467,7 +467,7 @@ public static void uint3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -491,7 +491,7 @@ public static void uint3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_add_wide_wide() { uint3 a0 = uint3(2135171378, 21433296, 1954723494); @@ -515,7 +515,7 @@ public static void uint3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_add_wide_scalar() { uint3 a0 = uint3(665815972, 1783729250, 1591678394); @@ -539,7 +539,7 @@ public static void uint3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -563,7 +563,7 @@ public static void uint3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_sub_wide_wide() { uint3 a0 = uint3(1410318491, 1097280168, 1827039044); @@ -587,7 +587,7 @@ public static void uint3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_sub_wide_scalar() { uint3 a0 = uint3(1508669340, 1594795463, 266707545); @@ -611,7 +611,7 @@ public static void uint3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -635,7 +635,7 @@ public static void uint3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_mul_wide_wide() { uint3 a0 = uint3(61417577, 219585476, 1362520891); @@ -659,7 +659,7 @@ public static void uint3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_mul_wide_scalar() { uint3 a0 = uint3(871746615, 492532311, 570557670); @@ -683,7 +683,7 @@ public static void uint3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -707,7 +707,7 @@ public static void uint3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_div_wide_wide() { uint3 a0 = uint3(333171510, 858154903, 1181365836); @@ -731,7 +731,7 @@ public static void uint3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_div_wide_scalar() { uint3 a0 = uint3(1433072926, 1073958635, 1195142312); @@ -755,7 +755,7 @@ public static void uint3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -779,7 +779,7 @@ public static void uint3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_mod_wide_wide() { uint3 a0 = uint3(258342924, 1454754891, 723352342); @@ -803,7 +803,7 @@ public static void uint3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_mod_wide_scalar() { uint3 a0 = uint3(560988938, 629524514, 767711194); @@ -827,7 +827,7 @@ public static void uint3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -851,7 +851,7 @@ public static void uint3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_plus() { uint3 a0 = uint3(195392567, 222719748, 1002351013); @@ -871,7 +871,7 @@ public static void uint3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_neg() { uint3 a0 = uint3(1385088677, 94114564, 1350664872); @@ -891,7 +891,7 @@ public static void uint3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_prefix_inc() { uint3 a0 = uint3(780471723, 954741756, 272723451); @@ -911,7 +911,7 @@ public static void uint3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_postfix_inc() { uint3 a0 = uint3(241865086, 2145821641, 1596166022); @@ -931,7 +931,7 @@ public static void uint3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_prefix_dec() { uint3 a0 = uint3(1331961415, 1612382200, 1401591249); @@ -951,7 +951,7 @@ public static void uint3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_postfix_dec() { uint3 a0 = uint3(1870005937, 1708534798, 704493460); @@ -971,7 +971,7 @@ public static void uint3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_and_wide_wide() { uint3 a0 = uint3(1055241304, 859321394, 1088358961); @@ -995,7 +995,7 @@ public static void uint3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_and_wide_scalar() { uint3 a0 = uint3(1513158868, 284695609, 734595037); @@ -1019,7 +1019,7 @@ public static void uint3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1043,7 +1043,7 @@ public static void uint3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_or_wide_wide() { uint3 a0 = uint3(1920951869, 1750772852, 1420019191); @@ -1067,7 +1067,7 @@ public static void uint3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_or_wide_scalar() { uint3 a0 = uint3(1295304853, 1307252624, 350194630); @@ -1091,7 +1091,7 @@ public static void uint3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1115,7 +1115,7 @@ public static void uint3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_xor_wide_wide() { uint3 a0 = uint3(1843655608, 362425681, 640805534); @@ -1139,7 +1139,7 @@ public static void uint3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_xor_wide_scalar() { uint3 a0 = uint3(169345668, 176087064, 2084362901); @@ -1163,7 +1163,7 @@ public static void uint3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1187,7 +1187,7 @@ public static void uint3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_left_shift() { uint3 a0 = uint3(1129100049, 829482269, 1571297368); @@ -1211,7 +1211,7 @@ public static void uint3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_right_shift() { uint3 a0 = uint3(809126085, 908563670, 763568837); @@ -1235,7 +1235,7 @@ public static void uint3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_operator_bitwise_not() { uint3 a0 = uint3(111796841, 603562399, 745091931); @@ -1255,7 +1255,7 @@ public static void uint3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_shuffle_result_1() { uint3 a = uint3(0, 1, 2); @@ -1269,7 +1269,7 @@ public static void uint3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_shuffle_result_2() { uint3 a = uint3(0, 1, 2); @@ -1293,7 +1293,7 @@ public static void uint3_shuffle_result_2() TestUtils.AreEqual(uint2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_shuffle_result_3() { uint3 a = uint3(0, 1, 2); @@ -1317,7 +1317,7 @@ public static void uint3_shuffle_result_3() TestUtils.AreEqual(uint3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_shuffle_result_4() { uint3 a = uint3(0, 1, 2); @@ -1341,7 +1341,7 @@ public static void uint3_shuffle_result_4() TestUtils.AreEqual(uint4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void uint3_EqualsObjectOverride() { TestUtils.IsFalse(new uint3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint3x2.gen.cs b/src/Tests/Tests/Shared/TestUint3x2.gen.cs index 106b90dc..71742df7 100644 --- a/src/Tests/Tests/Shared/TestUint3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_zero() { TestUtils.AreEqual(0u, uint3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void uint3x2_zero() TestUtils.AreEqual(0u, uint3x2.zero.c1.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_equal_wide_wide() { uint3x2 a0 = uint3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void uint3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_equal_wide_scalar() { uint3x2 a0 = uint3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void uint3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -98,7 +98,7 @@ public static void uint3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_not_equal_wide_wide() { uint3x2 a0 = uint3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void uint3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_not_equal_wide_scalar() { uint3x2 a0 = uint3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void uint3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -170,7 +170,7 @@ public static void uint3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_less_wide_wide() { uint3x2 a0 = uint3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void uint3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_less_wide_scalar() { uint3x2 a0 = uint3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void uint3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -242,7 +242,7 @@ public static void uint3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_greater_wide_wide() { uint3x2 a0 = uint3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void uint3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_greater_wide_scalar() { uint3x2 a0 = uint3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void uint3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -314,7 +314,7 @@ public static void uint3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_less_equal_wide_wide() { uint3x2 a0 = uint3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void uint3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_less_equal_wide_scalar() { uint3x2 a0 = uint3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void uint3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -386,7 +386,7 @@ public static void uint3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_greater_equal_wide_wide() { uint3x2 a0 = uint3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void uint3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_greater_equal_wide_scalar() { uint3x2 a0 = uint3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void uint3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -458,7 +458,7 @@ public static void uint3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_add_wide_wide() { uint3x2 a0 = uint3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void uint3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_add_wide_scalar() { uint3x2 a0 = uint3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void uint3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -530,7 +530,7 @@ public static void uint3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_sub_wide_wide() { uint3x2 a0 = uint3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void uint3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_sub_wide_scalar() { uint3x2 a0 = uint3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void uint3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -602,7 +602,7 @@ public static void uint3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_mul_wide_wide() { uint3x2 a0 = uint3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void uint3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_mul_wide_scalar() { uint3x2 a0 = uint3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void uint3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -674,7 +674,7 @@ public static void uint3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_div_wide_wide() { uint3x2 a0 = uint3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void uint3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_div_wide_scalar() { uint3x2 a0 = uint3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void uint3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -746,7 +746,7 @@ public static void uint3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_mod_wide_wide() { uint3x2 a0 = uint3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void uint3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_mod_wide_scalar() { uint3x2 a0 = uint3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void uint3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -818,7 +818,7 @@ public static void uint3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_plus() { uint3x2 a0 = uint3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void uint3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_neg() { uint3x2 a0 = uint3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void uint3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_prefix_inc() { uint3x2 a0 = uint3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void uint3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_postfix_inc() { uint3x2 a0 = uint3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void uint3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_prefix_dec() { uint3x2 a0 = uint3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void uint3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_postfix_dec() { uint3x2 a0 = uint3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void uint3x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_and_wide_wide() { uint3x2 a0 = uint3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void uint3x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_and_wide_scalar() { uint3x2 a0 = uint3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void uint3x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void uint3x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_or_wide_wide() { uint3x2 a0 = uint3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void uint3x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_or_wide_scalar() { uint3x2 a0 = uint3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void uint3x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void uint3x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_xor_wide_wide() { uint3x2 a0 = uint3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void uint3x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_xor_wide_scalar() { uint3x2 a0 = uint3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void uint3x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void uint3x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_left_shift() { uint3x2 a0 = uint3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void uint3x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_right_shift() { uint3x2 a0 = uint3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void uint3x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x2_operator_bitwise_not() { uint3x2 a0 = uint3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); @@ -1222,7 +1222,7 @@ public static void uint3x2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint3x2_EqualsObjectOverride() { TestUtils.IsFalse(new uint3x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint3x3.gen.cs b/src/Tests/Tests/Shared/TestUint3x3.gen.cs index 5861b8a2..6e679bba 100644 --- a/src/Tests/Tests/Shared/TestUint3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_zero() { TestUtils.AreEqual(0u, uint3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void uint3x3_zero() TestUtils.AreEqual(0u, uint3x3.zero.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_identity() { TestUtils.AreEqual(1u, uint3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void uint3x3_identity() TestUtils.AreEqual(1u, uint3x3.identity.c2.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_equal_wide_wide() { uint3x3 a0 = uint3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367); @@ -67,7 +67,7 @@ public static void uint3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_equal_wide_scalar() { uint3x3 a0 = uint3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998); @@ -91,7 +91,7 @@ public static void uint3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -115,7 +115,7 @@ public static void uint3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_not_equal_wide_wide() { uint3x3 a0 = uint3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678); @@ -139,7 +139,7 @@ public static void uint3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_not_equal_wide_scalar() { uint3x3 a0 = uint3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423); @@ -163,7 +163,7 @@ public static void uint3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -187,7 +187,7 @@ public static void uint3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_less_wide_wide() { uint3x3 a0 = uint3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312); @@ -211,7 +211,7 @@ public static void uint3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_less_wide_scalar() { uint3x3 a0 = uint3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597); @@ -235,7 +235,7 @@ public static void uint3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -259,7 +259,7 @@ public static void uint3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_greater_wide_wide() { uint3x3 a0 = uint3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133); @@ -283,7 +283,7 @@ public static void uint3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_greater_wide_scalar() { uint3x3 a0 = uint3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855); @@ -307,7 +307,7 @@ public static void uint3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -331,7 +331,7 @@ public static void uint3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_less_equal_wide_wide() { uint3x3 a0 = uint3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541); @@ -355,7 +355,7 @@ public static void uint3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_less_equal_wide_scalar() { uint3x3 a0 = uint3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375); @@ -379,7 +379,7 @@ public static void uint3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -403,7 +403,7 @@ public static void uint3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_greater_equal_wide_wide() { uint3x3 a0 = uint3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826); @@ -427,7 +427,7 @@ public static void uint3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_greater_equal_wide_scalar() { uint3x3 a0 = uint3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669); @@ -451,7 +451,7 @@ public static void uint3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -475,7 +475,7 @@ public static void uint3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_add_wide_wide() { uint3x3 a0 = uint3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600); @@ -499,7 +499,7 @@ public static void uint3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_add_wide_scalar() { uint3x3 a0 = uint3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008); @@ -523,7 +523,7 @@ public static void uint3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -547,7 +547,7 @@ public static void uint3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_sub_wide_wide() { uint3x3 a0 = uint3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315); @@ -571,7 +571,7 @@ public static void uint3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_sub_wide_scalar() { uint3x3 a0 = uint3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113); @@ -595,7 +595,7 @@ public static void uint3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -619,7 +619,7 @@ public static void uint3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_mul_wide_wide() { uint3x3 a0 = uint3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583); @@ -643,7 +643,7 @@ public static void uint3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_mul_wide_scalar() { uint3x3 a0 = uint3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059); @@ -667,7 +667,7 @@ public static void uint3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -691,7 +691,7 @@ public static void uint3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_div_wide_wide() { uint3x3 a0 = uint3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195); @@ -715,7 +715,7 @@ public static void uint3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_div_wide_scalar() { uint3x3 a0 = uint3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136); @@ -739,7 +739,7 @@ public static void uint3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -763,7 +763,7 @@ public static void uint3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_mod_wide_wide() { uint3x3 a0 = uint3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101); @@ -787,7 +787,7 @@ public static void uint3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_mod_wide_scalar() { uint3x3 a0 = uint3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144); @@ -811,7 +811,7 @@ public static void uint3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -835,7 +835,7 @@ public static void uint3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_plus() { uint3x3 a0 = uint3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671); @@ -855,7 +855,7 @@ public static void uint3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_neg() { uint3x3 a0 = uint3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525); @@ -875,7 +875,7 @@ public static void uint3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_prefix_inc() { uint3x3 a0 = uint3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994); @@ -895,7 +895,7 @@ public static void uint3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_postfix_inc() { uint3x3 a0 = uint3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247); @@ -915,7 +915,7 @@ public static void uint3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_prefix_dec() { uint3x3 a0 = uint3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745); @@ -935,7 +935,7 @@ public static void uint3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_postfix_dec() { uint3x3 a0 = uint3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889); @@ -955,7 +955,7 @@ public static void uint3x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_and_wide_wide() { uint3x3 a0 = uint3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656); @@ -979,7 +979,7 @@ public static void uint3x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_and_wide_scalar() { uint3x3 a0 = uint3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263); @@ -1003,7 +1003,7 @@ public static void uint3x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1027,7 +1027,7 @@ public static void uint3x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_or_wide_wide() { uint3x3 a0 = uint3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869); @@ -1051,7 +1051,7 @@ public static void uint3x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_or_wide_scalar() { uint3x3 a0 = uint3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307); @@ -1075,7 +1075,7 @@ public static void uint3x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1099,7 +1099,7 @@ public static void uint3x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_xor_wide_wide() { uint3x3 a0 = uint3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251); @@ -1123,7 +1123,7 @@ public static void uint3x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_xor_wide_scalar() { uint3x3 a0 = uint3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873); @@ -1147,7 +1147,7 @@ public static void uint3x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1171,7 +1171,7 @@ public static void uint3x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_left_shift() { uint3x3 a0 = uint3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727); @@ -1195,7 +1195,7 @@ public static void uint3x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_right_shift() { uint3x3 a0 = uint3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393); @@ -1219,7 +1219,7 @@ public static void uint3x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x3_operator_bitwise_not() { uint3x3 a0 = uint3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628); @@ -1239,7 +1239,7 @@ public static void uint3x3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint3x3_EqualsObjectOverride() { TestUtils.IsFalse(new uint3x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint3x4.gen.cs b/src/Tests/Tests/Shared/TestUint3x4.gen.cs index 9832a2a7..00c414a7 100644 --- a/src/Tests/Tests/Shared/TestUint3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_zero() { TestUtils.AreEqual(0u, uint3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void uint3x4_zero() TestUtils.AreEqual(0u, uint3x4.zero.c3.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_equal_wide_wide() { uint3x4 a0 = uint3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void uint3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_equal_wide_scalar() { uint3x4 a0 = uint3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void uint3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -104,7 +104,7 @@ public static void uint3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_not_equal_wide_wide() { uint3x4 a0 = uint3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void uint3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_not_equal_wide_scalar() { uint3x4 a0 = uint3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void uint3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -176,7 +176,7 @@ public static void uint3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_less_wide_wide() { uint3x4 a0 = uint3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void uint3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_less_wide_scalar() { uint3x4 a0 = uint3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void uint3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -248,7 +248,7 @@ public static void uint3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_greater_wide_wide() { uint3x4 a0 = uint3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void uint3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_greater_wide_scalar() { uint3x4 a0 = uint3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void uint3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -320,7 +320,7 @@ public static void uint3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_less_equal_wide_wide() { uint3x4 a0 = uint3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void uint3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_less_equal_wide_scalar() { uint3x4 a0 = uint3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void uint3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -392,7 +392,7 @@ public static void uint3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_greater_equal_wide_wide() { uint3x4 a0 = uint3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void uint3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_greater_equal_wide_scalar() { uint3x4 a0 = uint3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void uint3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -464,7 +464,7 @@ public static void uint3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_add_wide_wide() { uint3x4 a0 = uint3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void uint3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_add_wide_scalar() { uint3x4 a0 = uint3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void uint3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -536,7 +536,7 @@ public static void uint3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_sub_wide_wide() { uint3x4 a0 = uint3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void uint3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_sub_wide_scalar() { uint3x4 a0 = uint3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void uint3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -608,7 +608,7 @@ public static void uint3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_mul_wide_wide() { uint3x4 a0 = uint3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void uint3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_mul_wide_scalar() { uint3x4 a0 = uint3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void uint3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -680,7 +680,7 @@ public static void uint3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_div_wide_wide() { uint3x4 a0 = uint3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void uint3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_div_wide_scalar() { uint3x4 a0 = uint3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void uint3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -752,7 +752,7 @@ public static void uint3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_mod_wide_wide() { uint3x4 a0 = uint3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void uint3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_mod_wide_scalar() { uint3x4 a0 = uint3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void uint3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -824,7 +824,7 @@ public static void uint3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_plus() { uint3x4 a0 = uint3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void uint3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_neg() { uint3x4 a0 = uint3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void uint3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_prefix_inc() { uint3x4 a0 = uint3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void uint3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_postfix_inc() { uint3x4 a0 = uint3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void uint3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_prefix_dec() { uint3x4 a0 = uint3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void uint3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_postfix_dec() { uint3x4 a0 = uint3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void uint3x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_and_wide_wide() { uint3x4 a0 = uint3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void uint3x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_and_wide_scalar() { uint3x4 a0 = uint3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void uint3x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void uint3x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_or_wide_wide() { uint3x4 a0 = uint3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void uint3x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_or_wide_scalar() { uint3x4 a0 = uint3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void uint3x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void uint3x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_xor_wide_wide() { uint3x4 a0 = uint3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void uint3x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_xor_wide_scalar() { uint3x4 a0 = uint3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void uint3x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void uint3x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_left_shift() { uint3x4 a0 = uint3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void uint3x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_right_shift() { uint3x4 a0 = uint3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void uint3x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3x4_operator_bitwise_not() { uint3x4 a0 = uint3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); @@ -1228,7 +1228,7 @@ public static void uint3x4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint3x4_EqualsObjectOverride() { TestUtils.IsFalse(new uint3x4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint4.gen.cs b/src/Tests/Tests/Shared/TestUint4.gen.cs index 49e0be49..833012cd 100644 --- a/src/Tests/Tests/Shared/TestUint4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_zero() { TestUtils.AreEqual(0u, uint4.zero.x); @@ -24,7 +24,7 @@ public static void uint4_zero() TestUtils.AreEqual(0u, uint4.zero.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_constructor() { uint4 a = new uint4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void uint4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_scalar_constructor() { uint4 a = new uint4(17u); @@ -44,7 +44,7 @@ public static void uint4_scalar_constructor() TestUtils.AreEqual(17u, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_static_constructor() { uint4 a = uint4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void uint4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_static_scalar_constructor() { uint4 a = uint4(17u); @@ -64,7 +64,7 @@ public static void uint4_static_scalar_constructor() TestUtils.AreEqual(17u, a.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_equal_wide_wide() { uint4 a0 = uint4(2105871082, 35218899, 1550755093, 764676020); @@ -88,7 +88,7 @@ public static void uint4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_equal_wide_scalar() { uint4 a0 = uint4(437822262, 2020661134, 541786900, 853113810); @@ -112,7 +112,7 @@ public static void uint4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -136,7 +136,7 @@ public static void uint4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_not_equal_wide_wide() { uint4 a0 = uint4(1977284100, 1293292704, 1547283851, 422428953); @@ -160,7 +160,7 @@ public static void uint4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_not_equal_wide_scalar() { uint4 a0 = uint4(1038269360, 1427812625, 103361237, 1347017023); @@ -184,7 +184,7 @@ public static void uint4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -208,7 +208,7 @@ public static void uint4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_less_wide_wide() { uint4 a0 = uint4(1486550609, 1779244308, 1602148045, 1614085440); @@ -232,7 +232,7 @@ public static void uint4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_less_wide_scalar() { uint4 a0 = uint4(796797557, 670113454, 933579492, 278884514); @@ -256,7 +256,7 @@ public static void uint4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -280,7 +280,7 @@ public static void uint4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_greater_wide_wide() { uint4 a0 = uint4(2087717754, 1725569452, 1298066182, 1693943616); @@ -304,7 +304,7 @@ public static void uint4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_greater_wide_scalar() { uint4 a0 = uint4(1208626274, 239697208, 1979453345, 1253474001); @@ -328,7 +328,7 @@ public static void uint4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -352,7 +352,7 @@ public static void uint4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_less_equal_wide_wide() { uint4 a0 = uint4(154092149, 1515170149, 1083970332, 785807178); @@ -376,7 +376,7 @@ public static void uint4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_less_equal_wide_scalar() { uint4 a0 = uint4(1479531977, 1427983411, 415250630, 1245345407); @@ -400,7 +400,7 @@ public static void uint4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -424,7 +424,7 @@ public static void uint4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_greater_equal_wide_wide() { uint4 a0 = uint4(8538378, 2131749726, 265427108, 523609761); @@ -448,7 +448,7 @@ public static void uint4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_greater_equal_wide_scalar() { uint4 a0 = uint4(2049236663, 182691143, 634973382, 1197012109); @@ -472,7 +472,7 @@ public static void uint4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -496,7 +496,7 @@ public static void uint4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_add_wide_wide() { uint4 a0 = uint4(2135171378, 21433296, 1954723494, 683604307); @@ -520,7 +520,7 @@ public static void uint4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_add_wide_scalar() { uint4 a0 = uint4(665815972, 1783729250, 1591678394, 1284528538); @@ -544,7 +544,7 @@ public static void uint4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -568,7 +568,7 @@ public static void uint4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_sub_wide_wide() { uint4 a0 = uint4(1410318491, 1097280168, 1827039044, 28881338); @@ -592,7 +592,7 @@ public static void uint4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_sub_wide_scalar() { uint4 a0 = uint4(1508669340, 1594795463, 266707545, 643102647); @@ -616,7 +616,7 @@ public static void uint4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -640,7 +640,7 @@ public static void uint4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_mul_wide_wide() { uint4 a0 = uint4(61417577, 219585476, 1362520891, 1511084277); @@ -664,7 +664,7 @@ public static void uint4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_mul_wide_scalar() { uint4 a0 = uint4(871746615, 492532311, 570557670, 2142306629); @@ -688,7 +688,7 @@ public static void uint4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -712,7 +712,7 @@ public static void uint4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_div_wide_wide() { uint4 a0 = uint4(333171510, 858154903, 1181365836, 671357749); @@ -736,7 +736,7 @@ public static void uint4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_div_wide_scalar() { uint4 a0 = uint4(1433072926, 1073958635, 1195142312, 536596719); @@ -760,7 +760,7 @@ public static void uint4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -784,7 +784,7 @@ public static void uint4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_mod_wide_wide() { uint4 a0 = uint4(258342924, 1454754891, 723352342, 1981431473); @@ -808,7 +808,7 @@ public static void uint4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_mod_wide_scalar() { uint4 a0 = uint4(560988938, 629524514, 767711194, 434281967); @@ -832,7 +832,7 @@ public static void uint4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -856,7 +856,7 @@ public static void uint4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_plus() { uint4 a0 = uint4(195392567, 222719748, 1002351013, 1570765263); @@ -876,7 +876,7 @@ public static void uint4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_neg() { uint4 a0 = uint4(1385088677, 94114564, 1350664872, 1458616659); @@ -896,7 +896,7 @@ public static void uint4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_prefix_inc() { uint4 a0 = uint4(780471723, 954741756, 272723451, 2142862245); @@ -916,7 +916,7 @@ public static void uint4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_postfix_inc() { uint4 a0 = uint4(241865086, 2145821641, 1596166022, 803592338); @@ -936,7 +936,7 @@ public static void uint4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_prefix_dec() { uint4 a0 = uint4(1331961415, 1612382200, 1401591249, 2042075388); @@ -956,7 +956,7 @@ public static void uint4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_postfix_dec() { uint4 a0 = uint4(1870005937, 1708534798, 704493460, 462940703); @@ -976,7 +976,7 @@ public static void uint4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_and_wide_wide() { uint4 a0 = uint4(1055241304, 859321394, 1088358961, 2090949513); @@ -1000,7 +1000,7 @@ public static void uint4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_and_wide_scalar() { uint4 a0 = uint4(1513158868, 284695609, 734595037, 1566510707); @@ -1024,7 +1024,7 @@ public static void uint4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1048,7 +1048,7 @@ public static void uint4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_or_wide_wide() { uint4 a0 = uint4(1920951869, 1750772852, 1420019191, 732977093); @@ -1072,7 +1072,7 @@ public static void uint4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_or_wide_scalar() { uint4 a0 = uint4(1295304853, 1307252624, 350194630, 1128063578); @@ -1096,7 +1096,7 @@ public static void uint4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1120,7 +1120,7 @@ public static void uint4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_xor_wide_wide() { uint4 a0 = uint4(1843655608, 362425681, 640805534, 1342040268); @@ -1144,7 +1144,7 @@ public static void uint4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_xor_wide_scalar() { uint4 a0 = uint4(169345668, 176087064, 2084362901, 1663924004); @@ -1168,7 +1168,7 @@ public static void uint4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1192,7 +1192,7 @@ public static void uint4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_left_shift() { uint4 a0 = uint4(1129100049, 829482269, 1571297368, 443753193); @@ -1216,7 +1216,7 @@ public static void uint4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_right_shift() { uint4 a0 = uint4(809126085, 908563670, 763568837, 1986717290); @@ -1240,7 +1240,7 @@ public static void uint4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_operator_bitwise_not() { uint4 a0 = uint4(111796841, 603562399, 745091931, 853183268); @@ -1260,7 +1260,7 @@ public static void uint4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_shuffle_result_1() { uint4 a = uint4(0, 1, 2, 3); @@ -1276,7 +1276,7 @@ public static void uint4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_shuffle_result_2() { uint4 a = uint4(0, 1, 2, 3); @@ -1300,7 +1300,7 @@ public static void uint4_shuffle_result_2() TestUtils.AreEqual(uint2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_shuffle_result_3() { uint4 a = uint4(0, 1, 2, 3); @@ -1324,7 +1324,7 @@ public static void uint4_shuffle_result_3() TestUtils.AreEqual(uint3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_shuffle_result_4() { uint4 a = uint4(0, 1, 2, 3); @@ -1348,7 +1348,7 @@ public static void uint4_shuffle_result_4() TestUtils.AreEqual(uint4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY)); } - [TestCase] + [TestCase /* For player builds */] public static void uint4_EqualsObjectOverride() { TestUtils.IsFalse(new uint4().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint4x2.gen.cs b/src/Tests/Tests/Shared/TestUint4x2.gen.cs index 4cf1fc14..9d2bba1f 100644 --- a/src/Tests/Tests/Shared/TestUint4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4x2 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_zero() { TestUtils.AreEqual(0u, uint4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void uint4x2_zero() TestUtils.AreEqual(0u, uint4x2.zero.c1.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_equal_wide_wide() { uint4x2 a0 = uint4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void uint4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_equal_wide_scalar() { uint4x2 a0 = uint4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void uint4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -100,7 +100,7 @@ public static void uint4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_not_equal_wide_wide() { uint4x2 a0 = uint4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void uint4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_not_equal_wide_scalar() { uint4x2 a0 = uint4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void uint4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -172,7 +172,7 @@ public static void uint4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_less_wide_wide() { uint4x2 a0 = uint4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void uint4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_less_wide_scalar() { uint4x2 a0 = uint4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void uint4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -244,7 +244,7 @@ public static void uint4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_greater_wide_wide() { uint4x2 a0 = uint4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void uint4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_greater_wide_scalar() { uint4x2 a0 = uint4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void uint4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -316,7 +316,7 @@ public static void uint4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_less_equal_wide_wide() { uint4x2 a0 = uint4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void uint4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_less_equal_wide_scalar() { uint4x2 a0 = uint4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void uint4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -388,7 +388,7 @@ public static void uint4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_greater_equal_wide_wide() { uint4x2 a0 = uint4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void uint4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_greater_equal_wide_scalar() { uint4x2 a0 = uint4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void uint4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -460,7 +460,7 @@ public static void uint4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_add_wide_wide() { uint4x2 a0 = uint4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void uint4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_add_wide_scalar() { uint4x2 a0 = uint4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void uint4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -532,7 +532,7 @@ public static void uint4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_sub_wide_wide() { uint4x2 a0 = uint4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void uint4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_sub_wide_scalar() { uint4x2 a0 = uint4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void uint4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -604,7 +604,7 @@ public static void uint4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_mul_wide_wide() { uint4x2 a0 = uint4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void uint4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_mul_wide_scalar() { uint4x2 a0 = uint4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void uint4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -676,7 +676,7 @@ public static void uint4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_div_wide_wide() { uint4x2 a0 = uint4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void uint4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_div_wide_scalar() { uint4x2 a0 = uint4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void uint4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -748,7 +748,7 @@ public static void uint4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_mod_wide_wide() { uint4x2 a0 = uint4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void uint4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_mod_wide_scalar() { uint4x2 a0 = uint4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void uint4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -820,7 +820,7 @@ public static void uint4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_plus() { uint4x2 a0 = uint4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void uint4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_neg() { uint4x2 a0 = uint4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void uint4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_prefix_inc() { uint4x2 a0 = uint4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void uint4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_postfix_inc() { uint4x2 a0 = uint4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void uint4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_prefix_dec() { uint4x2 a0 = uint4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void uint4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_postfix_dec() { uint4x2 a0 = uint4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void uint4x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_and_wide_wide() { uint4x2 a0 = uint4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void uint4x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_and_wide_scalar() { uint4x2 a0 = uint4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void uint4x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void uint4x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_or_wide_wide() { uint4x2 a0 = uint4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void uint4x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_or_wide_scalar() { uint4x2 a0 = uint4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void uint4x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void uint4x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_xor_wide_wide() { uint4x2 a0 = uint4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void uint4x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_xor_wide_scalar() { uint4x2 a0 = uint4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void uint4x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void uint4x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_left_shift() { uint4x2 a0 = uint4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void uint4x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_right_shift() { uint4x2 a0 = uint4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void uint4x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x2_operator_bitwise_not() { uint4x2 a0 = uint4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); @@ -1224,7 +1224,7 @@ public static void uint4x2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint4x2_EqualsObjectOverride() { TestUtils.IsFalse(new uint4x2().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint4x3.gen.cs b/src/Tests/Tests/Shared/TestUint4x3.gen.cs index 0bcde5e9..bc2aba8a 100644 --- a/src/Tests/Tests/Shared/TestUint4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4x3 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_zero() { TestUtils.AreEqual(0u, uint4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void uint4x3_zero() TestUtils.AreEqual(0u, uint4x3.zero.c2.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_equal_wide_wide() { uint4x3 a0 = uint4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void uint4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_equal_wide_scalar() { uint4x3 a0 = uint4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void uint4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -104,7 +104,7 @@ public static void uint4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_not_equal_wide_wide() { uint4x3 a0 = uint4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void uint4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_not_equal_wide_scalar() { uint4x3 a0 = uint4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void uint4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -176,7 +176,7 @@ public static void uint4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_less_wide_wide() { uint4x3 a0 = uint4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void uint4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_less_wide_scalar() { uint4x3 a0 = uint4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void uint4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -248,7 +248,7 @@ public static void uint4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_greater_wide_wide() { uint4x3 a0 = uint4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void uint4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_greater_wide_scalar() { uint4x3 a0 = uint4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void uint4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -320,7 +320,7 @@ public static void uint4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_less_equal_wide_wide() { uint4x3 a0 = uint4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void uint4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_less_equal_wide_scalar() { uint4x3 a0 = uint4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void uint4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -392,7 +392,7 @@ public static void uint4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_greater_equal_wide_wide() { uint4x3 a0 = uint4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void uint4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_greater_equal_wide_scalar() { uint4x3 a0 = uint4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void uint4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -464,7 +464,7 @@ public static void uint4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_add_wide_wide() { uint4x3 a0 = uint4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void uint4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_add_wide_scalar() { uint4x3 a0 = uint4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void uint4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -536,7 +536,7 @@ public static void uint4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_sub_wide_wide() { uint4x3 a0 = uint4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void uint4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_sub_wide_scalar() { uint4x3 a0 = uint4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void uint4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -608,7 +608,7 @@ public static void uint4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_mul_wide_wide() { uint4x3 a0 = uint4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void uint4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_mul_wide_scalar() { uint4x3 a0 = uint4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void uint4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -680,7 +680,7 @@ public static void uint4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_div_wide_wide() { uint4x3 a0 = uint4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void uint4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_div_wide_scalar() { uint4x3 a0 = uint4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void uint4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -752,7 +752,7 @@ public static void uint4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_mod_wide_wide() { uint4x3 a0 = uint4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void uint4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_mod_wide_scalar() { uint4x3 a0 = uint4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void uint4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -824,7 +824,7 @@ public static void uint4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_plus() { uint4x3 a0 = uint4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void uint4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_neg() { uint4x3 a0 = uint4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void uint4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_prefix_inc() { uint4x3 a0 = uint4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void uint4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_postfix_inc() { uint4x3 a0 = uint4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void uint4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_prefix_dec() { uint4x3 a0 = uint4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void uint4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_postfix_dec() { uint4x3 a0 = uint4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void uint4x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_and_wide_wide() { uint4x3 a0 = uint4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void uint4x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_and_wide_scalar() { uint4x3 a0 = uint4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void uint4x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void uint4x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_or_wide_wide() { uint4x3 a0 = uint4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void uint4x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_or_wide_scalar() { uint4x3 a0 = uint4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void uint4x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void uint4x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_xor_wide_wide() { uint4x3 a0 = uint4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void uint4x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_xor_wide_scalar() { uint4x3 a0 = uint4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void uint4x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void uint4x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_left_shift() { uint4x3 a0 = uint4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void uint4x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_right_shift() { uint4x3 a0 = uint4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void uint4x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x3_operator_bitwise_not() { uint4x3 a0 = uint4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); @@ -1228,7 +1228,7 @@ public static void uint4x3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint4x3_EqualsObjectOverride() { TestUtils.IsFalse(new uint4x3().Equals((object)new int())); diff --git a/src/Tests/Tests/Shared/TestUint4x4.gen.cs b/src/Tests/Tests/Shared/TestUint4x4.gen.cs index 67f34ee1..03234c47 100644 --- a/src/Tests/Tests/Shared/TestUint4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4x4 { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_zero() { TestUtils.AreEqual(0u, uint4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void uint4x4_zero() TestUtils.AreEqual(0u, uint4x4.zero.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_identity() { TestUtils.AreEqual(1u, uint4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void uint4x4_identity() TestUtils.AreEqual(1u, uint4x4.identity.c3.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_equal_wide_wide() { uint4x4 a0 = uint4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805); @@ -81,7 +81,7 @@ public static void uint4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_equal_wide_scalar() { uint4x4 a0 = uint4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611); @@ -105,7 +105,7 @@ public static void uint4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -129,7 +129,7 @@ public static void uint4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_not_equal_wide_wide() { uint4x4 a0 = uint4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126); @@ -153,7 +153,7 @@ public static void uint4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_not_equal_wide_scalar() { uint4x4 a0 = uint4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260); @@ -177,7 +177,7 @@ public static void uint4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -201,7 +201,7 @@ public static void uint4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_less_wide_wide() { uint4x4 a0 = uint4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012); @@ -225,7 +225,7 @@ public static void uint4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_less_wide_scalar() { uint4x4 a0 = uint4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157); @@ -249,7 +249,7 @@ public static void uint4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -273,7 +273,7 @@ public static void uint4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_greater_wide_wide() { uint4x4 a0 = uint4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063); @@ -297,7 +297,7 @@ public static void uint4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_greater_wide_scalar() { uint4x4 a0 = uint4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537); @@ -321,7 +321,7 @@ public static void uint4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -345,7 +345,7 @@ public static void uint4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_less_equal_wide_wide() { uint4x4 a0 = uint4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458); @@ -369,7 +369,7 @@ public static void uint4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_less_equal_wide_scalar() { uint4x4 a0 = uint4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699); @@ -393,7 +393,7 @@ public static void uint4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -417,7 +417,7 @@ public static void uint4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_greater_equal_wide_wide() { uint4x4 a0 = uint4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690); @@ -441,7 +441,7 @@ public static void uint4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_greater_equal_wide_scalar() { uint4x4 a0 = uint4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144); @@ -465,7 +465,7 @@ public static void uint4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -489,7 +489,7 @@ public static void uint4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_add_wide_wide() { uint4x4 a0 = uint4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699); @@ -513,7 +513,7 @@ public static void uint4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_add_wide_scalar() { uint4x4 a0 = uint4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741); @@ -537,7 +537,7 @@ public static void uint4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -561,7 +561,7 @@ public static void uint4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_sub_wide_wide() { uint4x4 a0 = uint4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464); @@ -585,7 +585,7 @@ public static void uint4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_sub_wide_scalar() { uint4x4 a0 = uint4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902); @@ -609,7 +609,7 @@ public static void uint4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -633,7 +633,7 @@ public static void uint4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_mul_wide_wide() { uint4x4 a0 = uint4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174); @@ -657,7 +657,7 @@ public static void uint4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_mul_wide_scalar() { uint4x4 a0 = uint4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135); @@ -681,7 +681,7 @@ public static void uint4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -705,7 +705,7 @@ public static void uint4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_div_wide_wide() { uint4x4 a0 = uint4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781); @@ -729,7 +729,7 @@ public static void uint4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_div_wide_scalar() { uint4x4 a0 = uint4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263); @@ -753,7 +753,7 @@ public static void uint4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -777,7 +777,7 @@ public static void uint4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_mod_wide_wide() { uint4x4 a0 = uint4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943); @@ -801,7 +801,7 @@ public static void uint4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_mod_wide_scalar() { uint4x4 a0 = uint4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114); @@ -825,7 +825,7 @@ public static void uint4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -849,7 +849,7 @@ public static void uint4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_plus() { uint4x4 a0 = uint4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903); @@ -869,7 +869,7 @@ public static void uint4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_neg() { uint4x4 a0 = uint4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416); @@ -889,7 +889,7 @@ public static void uint4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_prefix_inc() { uint4x4 a0 = uint4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230); @@ -909,7 +909,7 @@ public static void uint4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_postfix_inc() { uint4x4 a0 = uint4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180); @@ -929,7 +929,7 @@ public static void uint4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_prefix_dec() { uint4x4 a0 = uint4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619); @@ -949,7 +949,7 @@ public static void uint4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_postfix_dec() { uint4x4 a0 = uint4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301); @@ -969,7 +969,7 @@ public static void uint4x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_and_wide_wide() { uint4x4 a0 = uint4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376); @@ -993,7 +993,7 @@ public static void uint4x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_and_wide_scalar() { uint4x4 a0 = uint4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952); @@ -1017,7 +1017,7 @@ public static void uint4x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1041,7 +1041,7 @@ public static void uint4x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_or_wide_wide() { uint4x4 a0 = uint4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729); @@ -1065,7 +1065,7 @@ public static void uint4x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_or_wide_scalar() { uint4x4 a0 = uint4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773); @@ -1089,7 +1089,7 @@ public static void uint4x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1113,7 +1113,7 @@ public static void uint4x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_xor_wide_wide() { uint4x4 a0 = uint4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576); @@ -1137,7 +1137,7 @@ public static void uint4x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_xor_wide_scalar() { uint4x4 a0 = uint4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598); @@ -1161,7 +1161,7 @@ public static void uint4x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1185,7 +1185,7 @@ public static void uint4x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_left_shift() { uint4x4 a0 = uint4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915); @@ -1209,7 +1209,7 @@ public static void uint4x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_right_shift() { uint4x4 a0 = uint4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287); @@ -1233,7 +1233,7 @@ public static void uint4x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4x4_operator_bitwise_not() { uint4x4 a0 = uint4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736); @@ -1253,7 +1253,7 @@ public static void uint4x4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCase] + [TestCase /* For player builds */] public static void uint4x4_EqualsObjectOverride() { TestUtils.IsFalse(new uint4x4().Equals((object)new int())); diff --git a/src/Tests/Tests/TestMath2.cs b/src/Tests/Tests/TestMath2.cs index 09e2d3a9..7bbac675 100644 --- a/src/Tests/Tests/TestMath2.cs +++ b/src/Tests/Tests/TestMath2.cs @@ -1,13 +1,14 @@ using NUnit.Framework; using static Unity.Mathematics.math; using Burst.Compiler.IL.Tests; +using System; namespace Unity.Mathematics.Tests { [TestFixture] public partial class TestMath { - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public unsafe void hash_blob() { byte[] testData = { @@ -59,5 +60,71 @@ public unsafe void hash_blob() } } } + + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + public unsafe void hash_blob_unaligned() + { + byte[] testData = { + 0x0d, 0x26, 0x1c, 0xeb, 0x56, 0x3a, 0x9c, 0x18, 0x93, 0xb6, + 0xc1, 0x99, 0x5e, 0x04, 0x92, 0x4f, 0x6e, 0xb7, 0x42, 0x53, + 0x23, 0xcf, 0xe3, 0xbf, 0x16, 0x64, 0x79, 0x08, 0xc1, 0x01, + 0x43, 0x89, 0x73, 0x8f, 0x76, 0x22, 0x0c, 0xee, 0x9b, 0x80, + 0x31, 0x83, 0xce, 0x33, 0x8b, 0xc7, 0x3f, 0x94, 0x33 + }; + + uint[] resultsWithZeroSeed = + { + 0x02cc5d05, 0x376a5b3f, 0x8ae13198, 0xf5b14d72, 0xcc7ddc84, + 0x763e5905, 0x58759392, 0x6bccbd00, 0x7d0f80c8, 0xef01ae48, + 0xe40aa3ad, 0x805e04ad, 0xf98a471c, 0xdd960ac1, 0x76a71750, + 0xd35e2baa, 0x0219f7da, 0xd5bd1fbd, 0x5f28c87e, 0xfe6f7995, + 0x69a43ac5, 0xec1a1a15, 0x7ae9f103, 0x8d04a688, 0xce3b35be, + 0x6b3f040c, 0xd5ea2e8c, 0x6989e79c, 0x8772f1fb, 0x0d7b7bf6, + 0x0796214b, 0x98ea65c4, 0x3884dd82, 0x59632484, 0x91c92822, + 0x72d28404, 0x167061b0, 0x32adc2ef, 0xbac3e672, 0xd39936b7, + 0x94e2c154, 0x8b4ff46c, 0x68976fd4, 0x04bee59a, 0x2ed62c69, + 0xabee69fd, 0xda11e266, 0xcebd9d38, 0x28eea5fd, 0x0210d6ee + }; + + + uint[] resultsWith_0xeb69cf40_seed = + { + 0x12c3b280, 0x9bc1f68d, 0x2f900b51, 0xdb77e20e, 0xf6e8f561, + 0x3f3f72f6, 0x15f9700f, 0x28beb671, 0xceece5e1, 0x7a9b5c81, + 0x62a84642, 0xf75666af, 0x8939f8ca, 0x6b84792b, 0x527ee836, + 0xa0782090, 0xce6b9926, 0xa608c73b, 0xa08ee6a3, 0xab77a6b2, + 0x4e174e68, 0x596f10d5, 0xa14c4d85, 0x509ab88d, 0xd14698a4, + 0xbaad2308, 0xbd04c3df, 0x5715fed1, 0x5cf23a74, 0xd4e844f9, + 0x166dcfba, 0xe3495e37, 0x1b18b2b3, 0x2e8c2aab, 0x40993321, + 0x4b84998a, 0xd062937d, 0x1b2c9f7b, 0x8a613ed3, 0x70d71291, + 0x1af38ea4, 0x460cb7e9, 0xf806e3a9, 0xec9b6b2e, 0x9972a843, + 0x1ff06d2a, 0xe8c5007b, 0x37d8fc40, 0x0dc4f639, 0x36edff4f + }; + + byte* buffer = stackalloc byte[testData.Length + 1]; + fixed (byte* p = testData) + { + UIntPtr address = (UIntPtr)p; + bool isUnaligned = ((ulong)address & 1) > 0; + byte* unalignedPtr = buffer; + + if (!isUnaligned) + { + ++unalignedPtr; + } + + Buffer.MemoryCopy(p, unalignedPtr, testData.Length + 1, testData.Length); + + for (int i = 0; i < 50; ++i) + { + TestUtils.AreEqual(hash(unalignedPtr, i, 0), resultsWithZeroSeed[i]); + } + + for (int i = 0; i < 50; ++i) + { + TestUtils.AreEqual(hash(unalignedPtr, i, 0xeb69cf40), resultsWith_0xeb69cf40_seed[i]); + } + } + } } } diff --git a/src/Tests/Tests/TestRandom.cs b/src/Tests/Tests/TestRandom.cs index 35bc9abd..9de2112b 100644 --- a/src/Tests/Tests/TestRandom.cs +++ b/src/Tests/Tests/TestRandom.cs @@ -115,14 +115,14 @@ private static double range_check(double x, double min, double max) } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool_uniform() { var rnd = new Random(0x6E624EB7u); ks_test((() => rnd.NextBool() ? 0.75 : 0.25), 2); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_uniform() { var rnd = new Random(0x6E624EB7u); @@ -130,14 +130,14 @@ public static void bool2_uniform() ks_test((() => rnd.NextBool2().y ? 0.75 : 0.25), 2); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool2_independent() { var rnd = new Random(0x6E624EB7u); r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool2().xy))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_uniform() { var rnd = new Random(0x6E624EB7u); @@ -146,7 +146,7 @@ public static void bool3_uniform() ks_test((() => rnd.NextBool3().z ? 0.75 : 0.25), 2); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool3_independent() { var rnd = new Random(0x6E624EB7u); @@ -155,7 +155,7 @@ public static void bool3_independent() r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().yz))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_uniform() { var rnd = new Random(0x6E624EB7u); @@ -165,7 +165,7 @@ public static void bool4_uniform() ks_test((() => rnd.NextBool4().w ? 0.75 : 0.25), 2); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void bool4_independent() { var rnd = new Random(0x6E624EB7u); @@ -177,21 +177,21 @@ public static void bool4_independent() r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().zw))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => ((rnd.NextInt() & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => (((uint)rnd.NextInt() >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -199,7 +199,7 @@ public static void int_uniform_max() ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -207,7 +207,7 @@ public static void int_uniform_max_limit() ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -217,7 +217,7 @@ public static void int_uniform_min_max() ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), range); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -227,7 +227,7 @@ public static void int_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -235,7 +235,7 @@ public static void int2_uniform_low_bits() ks_test((() => ((rnd.NextInt2().y & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -243,7 +243,7 @@ public static void int2_uniform_high_bits() ks_test((() => (((uint)rnd.NextInt2().y >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -252,7 +252,7 @@ public static void int2_uniform_max() ks_test((() => (range_check(rnd.NextInt2(max).y, 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -263,7 +263,7 @@ public static void int2_uniform_min_max() ks_test((() => (range_check(rnd.NextInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -274,21 +274,21 @@ public static void int2_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt2(min, max).y, min, max) + 0.5 - min) / range), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_independent_low_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => (rnd.NextInt2().xy & 255)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int2_independent_high_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => ((uint2)rnd.NextInt2().xy >> 24)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -297,7 +297,7 @@ public static void int3_uniform_low_bits() ks_test((() => ((rnd.NextInt3().z & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -306,7 +306,7 @@ public static void int3_uniform_high_bits() ks_test((() => (((uint)rnd.NextInt3().z >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -316,7 +316,7 @@ public static void int3_uniform_max() ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max.z) + 0.5) / max.z), max.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -326,7 +326,7 @@ public static void int3_uniform_max_limit() ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -338,7 +338,7 @@ public static void int3_uniform_min_max() ks_test((() => (range_check(rnd.NextInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), range.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -350,7 +350,7 @@ public static void int3_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt3(min, max).z, min, max) + 0.5 - min) / range), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -359,7 +359,7 @@ public static void int3_independent_low_bits() r_test(() => (rnd.NextInt3().yz & 255)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int3_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -368,7 +368,7 @@ public static void int3_independent_high_bits() r_test(() => ((uint2)rnd.NextInt3().yz >> 24)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -378,7 +378,7 @@ public static void int4_uniform_low_bits() ks_test((() => ((rnd.NextInt4().w & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -388,7 +388,7 @@ public static void int4_uniform_high_bits() ks_test((() => (((uint)rnd.NextInt4().w >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -399,7 +399,7 @@ public static void int4_uniform_max() ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max.w) + 0.5) / max.w), max.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -410,7 +410,7 @@ public static void int4_uniform_max_limit() ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -423,7 +423,7 @@ public static void int4_uniform_min_max() ks_test((() => (range_check(rnd.NextInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), range.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -436,7 +436,7 @@ public static void int4_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt4(min, max).w, min, max) + 0.5 - min) / range), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -448,7 +448,7 @@ public static void int4_independent_low_bits() r_test(() => (rnd.NextUInt4().zw & 255)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void int4_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -461,21 +461,21 @@ public static void int4_independent_high_bits() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => ((rnd.NextUInt() & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => ((rnd.NextUInt() >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -483,7 +483,7 @@ public static void uint_uniform_max() ks_test((() => (rnd.NextUInt(max) + 0.5) / max), (int)max); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -491,7 +491,7 @@ public static void uint_uniform_max_limit() ks_test((() => (rnd.NextUInt(max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -501,7 +501,7 @@ public static void uint_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt(min, max), min, max) + 0.5 - min) / range), (int)range); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -509,7 +509,7 @@ public static void uint_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt(0, max), 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -517,7 +517,7 @@ public static void uint2_uniform_low_bits() ks_test((() => ((rnd.NextUInt2().y & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -525,7 +525,7 @@ public static void uint2_uniform_high_bits() ks_test((() => ((rnd.NextUInt2().y >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -534,7 +534,7 @@ public static void uint2_uniform_max() ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max.y), (int)max.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -543,7 +543,7 @@ public static void uint2_uniform_max_limit() ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -554,7 +554,7 @@ public static void uint2_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -563,21 +563,21 @@ public static void uint2_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt2(0, max).y, 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_independent_low_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => (rnd.NextUInt2().xy & 255)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint2_independent_high_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => (rnd.NextUInt2().xy >> 24)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -586,7 +586,7 @@ public static void uint3_uniform_low_bits() ks_test((() => ((rnd.NextUInt3().z & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -595,7 +595,7 @@ public static void uint3_uniform_high_bits() ks_test((() => ((rnd.NextUInt3().z >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -605,7 +605,7 @@ public static void uint3_uniform_max() ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max.z), (int)max.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -615,7 +615,7 @@ public static void uint3_uniform_max_limit() ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -627,7 +627,7 @@ public static void uint3_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), (int)range.z); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -637,7 +637,7 @@ public static void uint3_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt3(0, max).z, 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -646,7 +646,7 @@ public static void uint3_independent_low_bits() r_test(() => (rnd.NextUInt3().yz & 255)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint3_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -655,7 +655,7 @@ public static void uint3_independent_high_bits() r_test(() => (rnd.NextUInt3().yz >> 24)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -665,7 +665,7 @@ public static void uint4_uniform_low_bits() ks_test((() => ((rnd.NextUInt4().w & 255u) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -675,7 +675,7 @@ public static void uint4_uniform_high_bits() ks_test((() => ((rnd.NextUInt4().w >> 24) + 0.5) / 256.0), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -686,7 +686,7 @@ public static void uint4_uniform_max() ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max.w), (int)max.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -697,7 +697,7 @@ public static void uint4_uniform_max_limit() ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -710,7 +710,7 @@ public static void uint4_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), (int)range.w); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -721,7 +721,7 @@ public static void uint4_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt4(0, max).w, 0, max) + 0.5) / max), 256); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -733,7 +733,7 @@ public static void uint4_independent_low_bits() r_test(() => (rnd.NextUInt4().zw & 255)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void uint4_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -745,21 +745,21 @@ public static void uint4_independent_high_bits() r_test(() => (rnd.NextUInt4().zw >> 24)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float_uniform() { var rnd = new Random(0x6E624EB7u); ks_test((() => range_check01(rnd.NextFloat()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => frac(rnd.NextFloat() * 65536.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -767,7 +767,7 @@ public static void float_uniform_max() ks_test((() => range_check(rnd.NextFloat(max), 0.0f, max) / max)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -777,7 +777,7 @@ public static void float_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat(min, max), min, max) -min) / range)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_uniform() { var rnd = new Random(0x6E624EB7u); @@ -785,7 +785,7 @@ public static void float2_uniform() ks_test((() => range_check01(rnd.NextFloat2().y))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -793,7 +793,7 @@ public static void float2_uniform_low_bits() ks_test((() => frac(rnd.NextFloat2().y * 65536.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -802,7 +802,7 @@ public static void float2_uniform_max() ks_test((() => range_check(rnd.NextFloat2(max).y, 0.0f, max.y) / max.y)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -813,14 +813,14 @@ public static void float2_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat2(min, max).y, min.y, max.y) - min.y) / range.y)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_independent() { var rnd = new Random(0x6E624EB7u); r_test((() => rnd.NextFloat2())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_uniform() { var rnd = new Random(0x6E624EB7u); @@ -829,7 +829,7 @@ public static void float3_uniform() ks_test((() => range_check01(rnd.NextFloat3().z))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -838,7 +838,7 @@ public static void float3_uniform_low_bits() ks_test((() => frac(rnd.NextFloat3().z * 65536.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -848,7 +848,7 @@ public static void float3_uniform_max() ks_test((() => range_check(rnd.NextFloat3(max).z, 0.0f, max.z) / max.z)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -860,7 +860,7 @@ public static void float3_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat3(min, max).z, min.z, max.z) - min.z) / range.z)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_independent() { var rnd = new Random(0x6E624EB7u); @@ -869,7 +869,7 @@ public static void float3_independent() r_test((() => rnd.NextFloat3().yz)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_uniform() { var rnd = new Random(0x6E624EB7u); @@ -879,7 +879,7 @@ public static void float4_uniform() ks_test((() => range_check01(rnd.NextFloat4().w))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -889,7 +889,7 @@ public static void float4_uniform_low_bits() ks_test((() => frac(rnd.NextFloat4().w * 65536.0f))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -900,7 +900,7 @@ public static void float4_uniform_max() ks_test((() => range_check(rnd.NextFloat4(max).w, 0.0f, max.w) / max.w)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -913,7 +913,7 @@ public static void float4_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat4(min, max).w, min.w, max.w) - min.w) / range.w)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float4_independent() { var rnd = new Random(0x6E624EB7u); @@ -925,21 +925,21 @@ public static void float4_independent() r_test((() => rnd.NextFloat4().zw)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double_uniform() { var rnd = new Random(0x6E624EB7u); ks_test((() => range_check01(rnd.NextDouble()))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => frac(rnd.NextDouble() * 35184372088832.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -947,7 +947,7 @@ public static void double_uniform_max() ks_test((() => range_check(rnd.NextDouble(max), 0.0, max) / max)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -957,7 +957,7 @@ public static void double_uniform_min_max() ks_test((() => (range_check(rnd.NextDouble(min, max), min, max) - min) / range)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_uniform() { var rnd = new Random(0x6E624EB7u); @@ -965,7 +965,7 @@ public static void double2_uniform() ks_test((() => range_check01(rnd.NextDouble2().y))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -973,7 +973,7 @@ public static void double2_uniform_low_bits() ks_test((() => frac(rnd.NextDouble2().y * 35184372088832.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -982,7 +982,7 @@ public static void double2_uniform_max() ks_test((() => range_check(rnd.NextDouble2(max).y, 0.0, max.y) / max.y)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -993,14 +993,14 @@ public static void double2_uniform_min_max() ks_test((() => (range_check(rnd.NextDouble2(min, max).y, min.y, max.y) - min.y) / range.y)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_independent() { var rnd = new Random(0x6E624EB7u); r_test((() => rnd.NextDouble2())); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_uniform() { var rnd = new Random(0x6E624EB7u); @@ -1009,7 +1009,7 @@ public static void double3_uniform() ks_test((() => range_check01(rnd.NextDouble3().z))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -1018,7 +1018,7 @@ public static void double3_uniform_low_bits() ks_test((() => frac(rnd.NextDouble3().z * 35184372088832.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -1028,7 +1028,7 @@ public static void double3_uniform_max() ks_test((() => range_check(rnd.NextDouble3(max).z, 0.0, max.z) / max.z)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -1041,7 +1041,7 @@ public static void double3_uniform_min_max() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_independent() { var rnd = new Random(0x6E624EB7u); @@ -1050,7 +1050,7 @@ public static void double3_independent() r_test((() => rnd.NextDouble3().yz)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_uniform() { var rnd = new Random(0x6E624EB7u); @@ -1060,7 +1060,7 @@ public static void double4_uniform() ks_test((() => range_check01(rnd.NextDouble4().w))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -1070,7 +1070,7 @@ public static void double4_uniform_low_bits() ks_test((() => frac(rnd.NextDouble4().w * 35184372088832.0))); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -1081,7 +1081,7 @@ public static void double4_uniform_max() ks_test((() => range_check(rnd.NextDouble4(max).w, 0.0, max.w) / max.w)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -1094,7 +1094,7 @@ public static void double4_uniform_min_max() ks_test((() => (range_check(rnd.NextDouble4(min, max).w, min.w, max.w) - min.w) / range.w)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double4_independent() { var rnd = new Random(0x6E624EB7u); @@ -1106,7 +1106,7 @@ public static void double4_independent() r_test((() => rnd.NextDouble4().zw)); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float2_direction() { var rnd = new Random(0x6E624EB7u); @@ -1117,7 +1117,7 @@ public static void float2_direction() }); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double2_direction() { var rnd = new Random(0x6E624EB7u); @@ -1129,7 +1129,7 @@ public static void double2_direction() } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void float3_direction() { var rnd = new Random(0x6E624EB7u); @@ -1145,7 +1145,7 @@ public static void float3_direction() }); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void double3_direction() { var rnd = new Random(0x6E624EB7u); @@ -1161,7 +1161,7 @@ public static void double3_direction() }); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void quaternion_rotation() { var rnd = new Random(0x6E624EB7u); @@ -1183,7 +1183,7 @@ public static void quaternion_rotation() }); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void consecutive_seeds_r_test() { // Check that drawing 1 number from many consecutive seeds has no correlation. @@ -1195,7 +1195,7 @@ public static void consecutive_seeds_r_test() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void consecutive_seeds_r_test2() { // Check that drawing 1 number from many consecutive seeds has no correlation. @@ -1207,7 +1207,7 @@ public static void consecutive_seeds_r_test2() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void consecutive_seeds_ks_test() { // Check that drawing 1 number from many consecutive seeds matches our expected distribution. @@ -1215,7 +1215,7 @@ public static void consecutive_seeds_ks_test() ks_test(() => Random.CreateFromIndex(seed++).NextDouble()); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void consecutive_seeds_ks_test2() { // Check that drawing 1 number from many consecutive seeds matches our expected distribution. @@ -1223,7 +1223,7 @@ public static void consecutive_seeds_ks_test2() ks_test(() => Random.CreateFromIndex(seed++).NextDouble()); } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void similar_seeds() { // Check to see that two consecutive seeds have no correlation when drawing @@ -1236,7 +1236,7 @@ public static void similar_seeds() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void similar_seeds2() { // Check to see that two consecutive seeds have no correlation when drawing @@ -1249,7 +1249,7 @@ public static void similar_seeds2() } } - [TestCompiler] + [TestCompiler /* For Burst testing */, TestCase /* For player builds */] public static void wang_hash() { TestUtils.AreEqual(3232319850u, Random.WangHash(0u)); diff --git a/src/Tests/Unity.Mathematics.Tests.asmdef b/src/Tests/Unity.Mathematics.Tests.asmdef index 6b374c8a..29a41728 100644 --- a/src/Tests/Unity.Mathematics.Tests.asmdef +++ b/src/Tests/Unity.Mathematics.Tests.asmdef @@ -1,13 +1,21 @@ { "name": "Unity.Mathematics.Tests", - "optionalUnityReferences": [ - "TestAssemblies" - ], + "rootNamespace": "", "references": [ - "Unity.Mathematics" + "Unity.Mathematics", + "UnityEngine.TestRunner" + ], + "includePlatforms": [], + "excludePlatforms": [], + "allowUnsafeCode": true, + "overrideReferences": true, + "precompiledReferences": [ + "nunit.framework.dll" ], - "includePlatforms": [ - "Editor" + "autoReferenced": false, + "defineConstraints": [ + "UNITY_INCLUDE_TESTS" ], - "allowUnsafeCode": true -} + "versionDefines": [], + "noEngineReferences": false +} \ No newline at end of file diff --git a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs index a6c203b3..778b2c25 100644 --- a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs +++ b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs @@ -2075,11 +2075,11 @@ private void BeginTest(StringBuilder str, string name, bool testCompiler = true) { if (testCompiler) { - str.Append("\t\t[TestCompiler]\n"); + str.Append("\t\t[TestCompiler /* For Burst testing */, TestCase /* For player builds */]\n"); } else { - str.Append("\t\t[TestCase]\n"); + str.Append("\t\t[TestCase /* For player builds */]\n"); } str.AppendFormat("\t\tpublic static void {0}()\n", name); diff --git a/src/Unity.Mathematics.PerformanceTests/TestHash.cs b/src/Unity.Mathematics.PerformanceTests/TestHash.cs new file mode 100644 index 00000000..106f451f --- /dev/null +++ b/src/Unity.Mathematics.PerformanceTests/TestHash.cs @@ -0,0 +1,58 @@ +using Unity.Burst; +using Unity.PerformanceTesting; +using NUnit.Framework; +using Unity.Collections.LowLevel.Unsafe; +using System; +using UnityEngine; + +namespace Unity.Mathematics.PerformanceTests +{ + [BurstCompile] + partial class TestHash + { + static readonly long kBufferBytes = 1024 * 1024; + static readonly long kBytesToHash = kBufferBytes - 1; + static readonly uint kExpectedHash = 1781740882; + + [Test, Performance] + public static unsafe void HashAligned() + { + Assert.AreEqual(kExpectedHash, Hash(false)); + } + + [Test, Performance] + public static unsafe void HashUnaligned() + { + Assert.AreEqual(kExpectedHash, Hash(true)); + } + + [BurstCompile(CompileSynchronously = true)] + static unsafe uint Hash(bool useUnalignedBuffer) + { + var ptr = (ulong)(UIntPtr)UnsafeUtility.Malloc(kBufferBytes, 16, Collections.Allocator.Persistent); + var ulongptr = (ulong)ptr; + uint seed = 0; + + if (useUnalignedBuffer && ((ulongptr & 1) == 0)) + { + ++ulongptr; + } + + var buffer = (void*)ulongptr; + + for (int i = 0; i < kBytesToHash; ++i) + { + ((byte*)buffer)[i] = 123; + } + + for (int i = 0; i < 100; ++i) + { + seed = math.hash(buffer, (int)kBytesToHash, seed); + } + + UnsafeUtility.Free((void*)ptr, Collections.Allocator.Persistent); + + return seed; + } + } +} \ No newline at end of file diff --git a/src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta b/src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta new file mode 100644 index 00000000..fcfb809b --- /dev/null +++ b/src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c1a8761ebc1ffa240aa484721a63ba9f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln index a0ea6974..ffeba31e 100644 --- a/src/Unity.Mathematics.sln +++ b/src/Unity.Mathematics.sln @@ -52,8 +52,16 @@ Global {2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x86.Build.0 = Release|Any CPU {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.ActiveCfg = Debug|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.Build.0 = Debug|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.ActiveCfg = Debug|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.Build.0 = Debug|Any CPU {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.ActiveCfg = Release|Any CPU {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.Build.0 = Release|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.ActiveCfg = Release|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.Build.0 = Release|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.ActiveCfg = Release|Any CPU + {293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs index 26b0d378..a1b4800d 100644 --- a/src/Unity.Mathematics/math.cs +++ b/src/Unity.Mathematics/math.cs @@ -6704,12 +6704,19 @@ public static float4 chgsign(float4 x, float4 y) return asfloat(asuint(x) ^ (asuint(y) & 0x80000000)); } - /// Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context. - /// A pointer to the beginning of the data. - /// Number of bytes to hash. - /// Starting seed value. - /// The 32 bit hash of the input data buffer. - public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0) + /// + /// Read 32 bits of data in little endian format. + /// + /// Memory address to read from. + /// 32 bits in little endian format. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static unsafe uint read32_little_endian(void* pBuffer) + { + byte* ptr = (byte*)pBuffer; + return (uint)ptr[0] | ((uint)ptr[1] << 8) | ((uint)ptr[2] << 16) | ((uint)ptr[3] << 24); + } + + private static unsafe uint hash_with_unaligned_loads(void* pBuffer, int numBytes, uint seed) { unchecked { @@ -6762,6 +6769,74 @@ public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0) } } + private static unsafe uint hash_without_unaligned_loads(void* pBuffer, int numBytes, uint seed) + { + unchecked + { + const uint Prime1 = 2654435761; + const uint Prime2 = 2246822519; + const uint Prime3 = 3266489917; + const uint Prime4 = 668265263; + const uint Prime5 = 374761393; + + byte* p = (byte*)pBuffer; + uint hash = seed + Prime5; + if (numBytes >= 16) + { + uint4 state = new uint4(Prime1 + Prime2, Prime2, 0, (uint)-Prime1) + seed; + + int count = numBytes >> 4; + for (int i = 0; i < count; ++i) + { + var data = new uint4(read32_little_endian(p), read32_little_endian(p + 4), read32_little_endian(p + 8), read32_little_endian(p + 12)); + state += data * Prime2; + state = rol(state, 13); + state *= Prime1; + p += 16; + } + + hash = rol(state.x, 1) + rol(state.y, 7) + rol(state.z, 12) + rol(state.w, 18); + } + + hash += (uint)numBytes; + + for (int i = 0; i < ((numBytes >> 2) & 3); ++i) + { + hash += read32_little_endian(p) * Prime3; + hash = rol(hash, 17) * Prime4; + p += 4; + } + + for (int i = 0; i < ((numBytes) & 3); ++i) + { + hash += (*p++) * Prime5; + hash = rol(hash, 11) * Prime1; + } + + hash ^= hash >> 15; + hash *= Prime2; + hash ^= hash >> 13; + hash *= Prime3; + hash ^= hash >> 16; + + return hash; + } + } + + /// Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context. + /// A pointer to the beginning of the data. + /// Number of bytes to hash. + /// Starting seed value. + /// The 32 bit hash of the input data buffer. + public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0) + { +#if !UNITY_64 && UNITY_ANDROID + return hash_without_unaligned_loads(pBuffer, numBytes, seed); +#else + return hash_with_unaligned_loads(pBuffer, numBytes, seed); +#endif + } + /// /// Unity's up axis (0, 1, 0). /// From 970e2eda7ed5a05ed87dc909c09c742ea370e6a9 Mon Sep 17 00:00:00 2001 From: Kevin MacAulay Vacheresse Date: Fri, 20 Oct 2023 11:12:15 -0230 Subject: [PATCH 23/50] Adds [Obsolete] tag to prevent warnings about implementing obsolete methods from the parent type avoiding CS0672. Warns users to not use these methods --- src/Unity.Mathematics.Editor/MatrixDrawer.cs | 3 ++- src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/Unity.Mathematics.Editor/MatrixDrawer.cs b/src/Unity.Mathematics.Editor/MatrixDrawer.cs index 3f31a0c7..00b4a4ff 100644 --- a/src/Unity.Mathematics.Editor/MatrixDrawer.cs +++ b/src/Unity.Mathematics.Editor/MatrixDrawer.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Collections.ObjectModel; using UnityEditor; @@ -23,6 +23,7 @@ namespace Unity.Mathematics.Editor [CustomPropertyDrawer(typeof(uint4x2)), CustomPropertyDrawer(typeof(uint4x3)), CustomPropertyDrawer(typeof(uint4x4))] class MatrixDrawer : PropertyDrawer { + [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)] public override bool CanCacheInspectorGUI(SerializedProperty property) { return false; diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs index 28d8f47f..f7c7dbff 100644 --- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs +++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs @@ -1,4 +1,4 @@ -using System; +using System; using UnityEditor; using UnityEngine; @@ -44,6 +44,7 @@ static class Content public static readonly GUIContent[] labels4 = { new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z"), new GUIContent("W") }; } + [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)] public override bool CanCacheInspectorGUI(SerializedProperty property) { return false; From cefc6827bb7d496180d97e125841b479c1740f55 Mon Sep 17 00:00:00 2001 From: Kevin MacAulay Vacheresse Date: Fri, 20 Oct 2023 11:15:42 -0230 Subject: [PATCH 24/50] Update changelog --- src/CHANGELOG.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 2055eee9..aee5185a 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -1,10 +1,10 @@ # Changelog ## [Unreleased] -### Added -### Changed + ### Deprecated -### Removed +* `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` are now marked as `[Obsolete]`. These methods never did anything, and still do not. They will be removed in a future release. + ### Fixed * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices. From 4c2b8ff74724bf8a24776acdcc5cccbf3751ea32 Mon Sep 17 00:00:00 2001 From: Kevin MacAulay Vacheresse Date: Fri, 20 Oct 2023 12:14:46 -0230 Subject: [PATCH 25/50] Cleanup changes to remove the obsolete methods in UNITY_2023_2_OR_NEWER outright --- src/CHANGELOG.md | 4 +--- src/Unity.Mathematics.Editor/MatrixDrawer.cs | 3 ++- src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs | 3 ++- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index aee5185a..f51a25d0 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -2,11 +2,9 @@ ## [Unreleased] -### Deprecated -* `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` are now marked as `[Obsolete]`. These methods never did anything, and still do not. They will be removed in a future release. - ### Fixed * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices. +* Fixed obsolete method usage warnings for `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` in UNITY_2023_2_OR_NEWER. ## [1.3.1] - 2023-07-12 diff --git a/src/Unity.Mathematics.Editor/MatrixDrawer.cs b/src/Unity.Mathematics.Editor/MatrixDrawer.cs index 00b4a4ff..f59d2c91 100644 --- a/src/Unity.Mathematics.Editor/MatrixDrawer.cs +++ b/src/Unity.Mathematics.Editor/MatrixDrawer.cs @@ -23,11 +23,12 @@ namespace Unity.Mathematics.Editor [CustomPropertyDrawer(typeof(uint4x2)), CustomPropertyDrawer(typeof(uint4x3)), CustomPropertyDrawer(typeof(uint4x4))] class MatrixDrawer : PropertyDrawer { - [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)] +#if !UNITY_2023_2_OR_NEWER public override bool CanCacheInspectorGUI(SerializedProperty property) { return false; } +#endif public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs index f7c7dbff..cde01f38 100644 --- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs +++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs @@ -44,11 +44,12 @@ static class Content public static readonly GUIContent[] labels4 = { new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z"), new GUIContent("W") }; } - [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)] +#if !UNITY_2023_2_OR_NEWER public override bool CanCacheInspectorGUI(SerializedProperty property) { return false; } +#endif public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { From bf1c2c51725f6b69de6509595f2b7d491e0c3782 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Thu, 30 Nov 2023 19:34:20 -0800 Subject: [PATCH 26/50] Fix project? --- .../Unity.Mathematics.csproj | 89 ------------------- 1 file changed, 89 deletions(-) diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 296381f2..9ecf8cea 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -13,95 +13,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From 3ce550cdfc793de130419303137820ee48f718ab Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Mon, 4 Dec 2023 15:21:43 -0800 Subject: [PATCH 27/50] Revert "recover burst compatibility" This reverts commit 6c978302ee98bcebadc69a9e8ddb039a8a33f70c. --- .../Properties/AssemblyInfo.cs | 47 +++++++++++++++++++ .../Unity.Mathematics.csproj | 38 ++++++++++++--- 2 files changed, 79 insertions(+), 6 deletions(-) create mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..c090f5b4 --- /dev/null +++ b/src/Unity.Mathematics/Properties/AssemblyInfo.cs @@ -0,0 +1,47 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +#if !UNITY_DOTSPLAYER +using System.Reflection; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. + +[assembly: AssemblyTitle("Unity.Mathematics")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Unity.Mathematics")] +[assembly: AssemblyCopyright("Copyright © 2017")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. + +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM + +[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] + +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +#endif + +[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")] +[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")] +[assembly: InternalsVisibleTo("btests")] \ No newline at end of file diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 9ecf8cea..a6d2d9d4 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -1,7 +1,27 @@ - + + + - net471 + Debug + AnyCPU + {19810344-7387-4155-935F-BDD5CC61F0BF} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Library + Properties + Unity + Unity.Mathematics + v4.7.1 + 512 + + AnyCPU + true + full + false + ..\..\build\bin\Debug\ + DEBUG;TRACE + prompt + 4 true false ..\..\build\bin\$(Configuration)\ @@ -9,12 +29,18 @@ 1.0.0.0 - - + - - \ No newline at end of file + + + From 539d4ef8c78bd9c3eafa50d5f414416e15be385b Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Tue, 5 Dec 2023 11:31:47 -0800 Subject: [PATCH 28/50] Revert "Revert "recover burst compatibility"" This reverts commit 3ce550cdfc793de130419303137820ee48f718ab. --- .../Properties/AssemblyInfo.cs | 47 ------------------- .../Unity.Mathematics.csproj | 38 +++------------ 2 files changed, 6 insertions(+), 79 deletions(-) delete mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs deleted file mode 100644 index c090f5b4..00000000 --- a/src/Unity.Mathematics/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,47 +0,0 @@ -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -#if !UNITY_DOTSPLAYER -using System.Reflection; - -// General Information about an assembly is controlled through the following -// set of attributes. Change these attribute values to modify the information -// associated with an assembly. - -[assembly: AssemblyTitle("Unity.Mathematics")] -[assembly: AssemblyDescription("")] -[assembly: AssemblyConfiguration("")] -[assembly: AssemblyCompany("")] -[assembly: AssemblyProduct("Unity.Mathematics")] -[assembly: AssemblyCopyright("Copyright © 2017")] -[assembly: AssemblyTrademark("")] -[assembly: AssemblyCulture("")] - -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from -// COM, set the ComVisible attribute to true on that type. - -[assembly: ComVisible(false)] - -// The following GUID is for the ID of the typelib if this project is exposed to COM - -[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")] - -// Version information for an assembly consists of the following four values: -// -// Major Version -// Minor Version -// Build Number -// Revision -// -// You can specify all the values or you can default the Build and Revision Numbers -// by using the '*' as shown below: -// [assembly: AssemblyVersion("1.0.*")] - -[assembly: AssemblyVersion("1.0.0.0")] -[assembly: AssemblyFileVersion("1.0.0.0")] -#endif - -[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")] -[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")] -[assembly: InternalsVisibleTo("btests")] \ No newline at end of file diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index a6d2d9d4..9ecf8cea 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -1,27 +1,7 @@ - - - + - Debug - AnyCPU - {19810344-7387-4155-935F-BDD5CC61F0BF} - {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - Library - Properties - Unity - Unity.Mathematics - v4.7.1 - 512 - - + net471 AnyCPU - true - full - false - ..\..\build\bin\Debug\ - DEBUG;TRACE - prompt - 4 true false ..\..\build\bin\$(Configuration)\ @@ -29,18 +9,12 @@ 1.0.0.0 - + + - - - + + \ No newline at end of file From 2ef61553306c3efd9a341479e4a7e354b1159e7f Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Tue, 5 Dec 2023 11:45:27 -0800 Subject: [PATCH 29/50] Make internals visible to mathematics tests. --- src/Tests/Unity.Mathematics.Tests.csproj | 4 ++-- src/Unity.Mathematics/Geometry/MinMaxAABB.cs | 4 ++-- src/Unity.Mathematics/Geometry/Plane.cs | 2 +- src/Unity.Mathematics/Unity.Mathematics.csproj | 1 + 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj index 691f7fb0..db3c9463 100644 --- a/src/Tests/Unity.Mathematics.Tests.csproj +++ b/src/Tests/Unity.Mathematics.Tests.csproj @@ -105,7 +105,7 @@ - + @@ -145,4 +145,4 @@ --> - \ No newline at end of file + diff --git a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs index 6b5b666d..eb4a3876 100644 --- a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs +++ b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs @@ -16,7 +16,7 @@ namespace Unity.Mathematics.Geometry /// [System.Serializable] [Il2CppEagerStaticClassConstruction] - public struct MinMaxAABB : IEquatable + internal struct MinMaxAABB : IEquatable { /// /// The minimum point contained by the AABB. @@ -213,7 +213,7 @@ public override string ToString() } } - public static partial class Math + internal static partial class Math { /// /// Transforms the AABB with the given transform. diff --git a/src/Unity.Mathematics/Geometry/Plane.cs b/src/Unity.Mathematics/Geometry/Plane.cs index 5094bb94..92d47c5e 100644 --- a/src/Unity.Mathematics/Geometry/Plane.cs +++ b/src/Unity.Mathematics/Geometry/Plane.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Geometry [DebuggerDisplay("{Normal}, {Distance}")] [Serializable] [Il2CppEagerStaticClassConstruction] - public struct Plane + internal struct Plane { /// /// A plane in the form Ax + By + Cz + Dw = 0. diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 9ecf8cea..6a97724f 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -15,6 +15,7 @@ + \ No newline at end of file From bb2234d71933cf6fbd66807a264331881ffb0f72 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Tue, 5 Dec 2023 12:02:20 -0800 Subject: [PATCH 30/50] Make Geometry stuff public again for burst. --- src/Unity.Mathematics/Geometry/MinMaxAABB.cs | 4 ++-- src/Unity.Mathematics/Geometry/Plane.cs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs index eb4a3876..6b5b666d 100644 --- a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs +++ b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs @@ -16,7 +16,7 @@ namespace Unity.Mathematics.Geometry /// [System.Serializable] [Il2CppEagerStaticClassConstruction] - internal struct MinMaxAABB : IEquatable + public struct MinMaxAABB : IEquatable { /// /// The minimum point contained by the AABB. @@ -213,7 +213,7 @@ public override string ToString() } } - internal static partial class Math + public static partial class Math { /// /// Transforms the AABB with the given transform. diff --git a/src/Unity.Mathematics/Geometry/Plane.cs b/src/Unity.Mathematics/Geometry/Plane.cs index 92d47c5e..5094bb94 100644 --- a/src/Unity.Mathematics/Geometry/Plane.cs +++ b/src/Unity.Mathematics/Geometry/Plane.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Geometry [DebuggerDisplay("{Normal}, {Distance}")] [Serializable] [Il2CppEagerStaticClassConstruction] - internal struct Plane + public struct Plane { /// /// A plane in the form Ax + By + Cz + Dw = 0. From c1cffbda9db093e030fee5e745f4161ee1675537 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Tue, 5 Dec 2023 12:14:26 -0800 Subject: [PATCH 31/50] Make svd public for burst testing. --- src/Unity.Mathematics/svd.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs index b0a32112..fa50b669 100644 --- a/src/Unity.Mathematics/svd.cs +++ b/src/Unity.Mathematics/svd.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics // Computing the singular value decomposition of 3x3 matrices with minimal branching and elementary floating point operations, // A.McAdams, A.Selle, R.Tamstorf, J.Teran and E.Sifakis, University of Wisconsin - Madison technical report TR1690, May 2011 [Il2CppEagerStaticClassConstruction] - static class svd + static public class svd { [MethodImpl(MethodImplOptions.AggressiveInlining)] static void condSwap(bool c, ref float x, ref float y) From 8d574b191ec7a9e482bf81f3053b61f3565a0fc8 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Tue, 5 Dec 2023 12:32:17 -0800 Subject: [PATCH 32/50] Make internals visible to burst. --- src/Unity.Mathematics/Unity.Mathematics.csproj | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index 6a97724f..a87b134b 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -16,6 +16,8 @@ + + \ No newline at end of file From 0aed4d2090ca2993afef016e192d50dcf0306c21 Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Tue, 5 Dec 2023 14:08:30 -0800 Subject: [PATCH 33/50] Make methods public for burst testing. --- src/Unity.Mathematics/Unity.Mathematics.csproj | 2 -- src/Unity.Mathematics/svd.cs | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj index a87b134b..6a97724f 100644 --- a/src/Unity.Mathematics/Unity.Mathematics.csproj +++ b/src/Unity.Mathematics/Unity.Mathematics.csproj @@ -16,8 +16,6 @@ - - \ No newline at end of file diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs index fa50b669..d57e748a 100644 --- a/src/Unity.Mathematics/svd.cs +++ b/src/Unity.Mathematics/svd.cs @@ -151,7 +151,7 @@ static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) => math.select(math.rcp(x), float3.zero, math.abs(x) < epsilon); [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static float3x3 svdInverse(float3x3 a) + public static float3x3 svdInverse(float3x3 a) { var e = singularValuesDecomposition(a, out var u, out var v); var um = math.float3x3(u); @@ -161,7 +161,7 @@ internal static float3x3 svdInverse(float3x3 a) } [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static quaternion svdRotation(float3x3 a) + public static quaternion svdRotation(float3x3 a) { singularValuesDecomposition(a, out var u, out var v); return math.mul(u, math.conjugate(v)); From 61c80455fd31a969684f6d7ea546cd90197a53da Mon Sep 17 00:00:00 2001 From: Dale Kim <3121968+unpacklo@users.noreply.github.com> Date: Thu, 7 Dec 2023 13:12:57 -0800 Subject: [PATCH 34/50] Use only TestCompiler or TestCase, not both. Using both breaks burst testing. --- src/Tests/Tests/Shared/TestAffineTransform.cs | 28 +- src/Tests/Tests/Shared/TestBitmanipulation.cs | 122 +-- src/Tests/Tests/Shared/TestBool2.gen.cs | 40 +- src/Tests/Tests/Shared/TestBool2x2.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool2x3.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool2x4.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool3.gen.cs | 40 +- src/Tests/Tests/Shared/TestBool3x2.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool3x3.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool3x4.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool4.gen.cs | 40 +- src/Tests/Tests/Shared/TestBool4x2.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool4x3.gen.cs | 32 +- src/Tests/Tests/Shared/TestBool4x4.gen.cs | 32 +- src/Tests/Tests/Shared/TestDouble2.gen.cs | 96 +- src/Tests/Tests/Shared/TestDouble2x2.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble2x3.gen.cs | 80 +- src/Tests/Tests/Shared/TestDouble2x4.gen.cs | 80 +- src/Tests/Tests/Shared/TestDouble3.gen.cs | 96 +- src/Tests/Tests/Shared/TestDouble3x2.gen.cs | 80 +- src/Tests/Tests/Shared/TestDouble3x3.gen.cs | 82 +- src/Tests/Tests/Shared/TestDouble3x4.gen.cs | 80 +- src/Tests/Tests/Shared/TestDouble4.gen.cs | 96 +- src/Tests/Tests/Shared/TestDouble4x2.gen.cs | 80 +- src/Tests/Tests/Shared/TestDouble4x3.gen.cs | 80 +- src/Tests/Tests/Shared/TestDouble4x4.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat2.gen.cs | 96 +- src/Tests/Tests/Shared/TestFloat2x2.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat2x3.gen.cs | 80 +- src/Tests/Tests/Shared/TestFloat2x4.gen.cs | 80 +- src/Tests/Tests/Shared/TestFloat3.gen.cs | 96 +- src/Tests/Tests/Shared/TestFloat3x2.gen.cs | 80 +- src/Tests/Tests/Shared/TestFloat3x3.gen.cs | 82 +- src/Tests/Tests/Shared/TestFloat3x4.gen.cs | 80 +- src/Tests/Tests/Shared/TestFloat4.gen.cs | 96 +- src/Tests/Tests/Shared/TestFloat4x2.gen.cs | 80 +- src/Tests/Tests/Shared/TestFloat4x3.gen.cs | 80 +- src/Tests/Tests/Shared/TestFloat4x4.gen.cs | 82 +- src/Tests/Tests/Shared/TestHalf.cs | 90 +- src/Tests/Tests/Shared/TestInt2.gen.cs | 120 +-- src/Tests/Tests/Shared/TestInt2x2.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt2x3.gen.cs | 104 +-- src/Tests/Tests/Shared/TestInt2x4.gen.cs | 104 +-- src/Tests/Tests/Shared/TestInt3.gen.cs | 120 +-- src/Tests/Tests/Shared/TestInt3x2.gen.cs | 104 +-- src/Tests/Tests/Shared/TestInt3x3.gen.cs | 106 +-- src/Tests/Tests/Shared/TestInt3x4.gen.cs | 104 +-- src/Tests/Tests/Shared/TestInt4.gen.cs | 120 +-- src/Tests/Tests/Shared/TestInt4x2.gen.cs | 104 +-- src/Tests/Tests/Shared/TestInt4x3.gen.cs | 104 +-- src/Tests/Tests/Shared/TestInt4x4.gen.cs | 106 +-- src/Tests/Tests/Shared/TestMath.cs | 568 ++++++------ src/Tests/Tests/Shared/TestMath.gen.cs | 820 +++++++++--------- src/Tests/Tests/Shared/TestMatrix.cs | 122 +-- src/Tests/Tests/Shared/TestMinMaxAABB.cs | 90 +- src/Tests/Tests/Shared/TestPlane.cs | 46 +- src/Tests/Tests/Shared/TestQuaternion.cs | 56 +- src/Tests/Tests/Shared/TestRigidTransform.cs | 16 +- src/Tests/Tests/Shared/TestSvd.cs | 18 +- src/Tests/Tests/Shared/TestUint2.gen.cs | 120 +-- src/Tests/Tests/Shared/TestUint2x2.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint2x3.gen.cs | 104 +-- src/Tests/Tests/Shared/TestUint2x4.gen.cs | 104 +-- src/Tests/Tests/Shared/TestUint3.gen.cs | 120 +-- src/Tests/Tests/Shared/TestUint3x2.gen.cs | 104 +-- src/Tests/Tests/Shared/TestUint3x3.gen.cs | 106 +-- src/Tests/Tests/Shared/TestUint3x4.gen.cs | 104 +-- src/Tests/Tests/Shared/TestUint4.gen.cs | 120 +-- src/Tests/Tests/Shared/TestUint4x2.gen.cs | 104 +-- src/Tests/Tests/Shared/TestUint4x3.gen.cs | 104 +-- src/Tests/Tests/Shared/TestUint4x4.gen.cs | 106 +-- src/Tests/Tests/TestMath2.cs | 4 +- src/Tests/Tests/TestRandom.cs | 232 ++--- .../VectorGenerator.cs | 2 +- 74 files changed, 3627 insertions(+), 3627 deletions(-) diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs index 77af61f8..b663fd65 100644 --- a/src/Tests/Tests/Shared/TestAffineTransform.cs +++ b/src/Tests/Tests/Shared/TestAffineTransform.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestAffineTransform { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_construct_from_float3x3() { const float tolerance = 1e-6f; @@ -20,7 +20,7 @@ public static void affine_transform_construct_from_float3x3() TestUtils.AreEqual(m3x3, testM3x3, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_construct_from_float3x4() { const float tolerance = 1e-6f; @@ -33,7 +33,7 @@ public static void affine_transform_construct_from_float3x4() TestUtils.AreEqual(m3x4, testM3x4, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_construct_from_float4x4() { const float tolerance = 1e-6f; @@ -46,7 +46,7 @@ public static void affine_transform_construct_from_float4x4() TestUtils.AreEqual(m4x4, testM4x4, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_construct_from_RigidTransform() { const float tolerance = 1e-6f; @@ -58,7 +58,7 @@ public static void affine_transform_construct_from_RigidTransform() TestUtils.AreEqual(r.pos, tx.t, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_inverse() { const float tolerance = 1e-6f; @@ -69,7 +69,7 @@ public static void affine_transform_inverse() TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_inverse_zero_rs_returns_zero() { const float tolerance = 1e-30f; @@ -80,7 +80,7 @@ public static void affine_transform_inverse_zero_rs_returns_zero() TestUtils.AreEqual(float3x4.zero, invTx, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_inverse_pico_scale() { // slightly larger tolerance (vs 1e-6f) for PS4 @@ -92,7 +92,7 @@ public static void affine_transform_inverse_pico_scale() TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_inverse_singular() { // it needs a bit larger tolerance for singular @@ -107,7 +107,7 @@ public static void affine_transform_inverse_singular() TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_decompose() { const float tolerance = 1e-6f; @@ -120,7 +120,7 @@ public static void affine_transform_decompose() TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_mul_vector() { float4x4 m = TestMatrix.test4x4_xyz; @@ -137,7 +137,7 @@ public static void affine_transform_mul_vector() TestUtils.AreEqual(mvector1, txvector1, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_rotate_vector() { float3x3 m = TestMatrix.test3x3_xyz; @@ -150,7 +150,7 @@ public static void affine_transform_rotate_vector() TestUtils.AreEqual(mvector0, txvector0, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_transform_point() { float4x4 m = float4x4(TestMatrix.test3x3_zyx, float3(1f, 2f, 3f)); @@ -163,11 +163,11 @@ public static void affine_transform_transform_point() TestUtils.AreEqual(mPt0, txPt0, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void affine_transform_zero() { TestUtils.AreEqual(float3x3.zero, AffineTransform.zero.rs); TestUtils.AreEqual(float3.zero, AffineTransform.zero.t); } } -} \ No newline at end of file +} diff --git a/src/Tests/Tests/Shared/TestBitmanipulation.cs b/src/Tests/Tests/Shared/TestBitmanipulation.cs index e3c91791..517d8d67 100644 --- a/src/Tests/Tests/Shared/TestBitmanipulation.cs +++ b/src/Tests/Tests/Shared/TestBitmanipulation.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBitmanipulation { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bitmask_bool4() { TestUtils.AreEqual(bitmask(new bool4(false, false, false, false)), 0b0000); @@ -23,7 +23,7 @@ public static void bitmask_bool4() TestUtils.AreEqual(bitmask(new bool4(true, true, true, false)), 0b0111); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_int1() { TestUtils.AreEqual(12, countbits( 0x01234567)); @@ -33,7 +33,7 @@ public static void countbits_int1() TestUtils.AreEqual(32, countbits(-1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_int2() { TestUtils.AreEqual(int2(0, 12), countbits(int2(0, 0x01234567))); @@ -41,21 +41,21 @@ public static void countbits_int2() TestUtils.AreEqual(int2(17, 32), countbits(int2(-0x456789AB, -1))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_int3() { TestUtils.AreEqual(int3(0, 12, 16), countbits(int3(0, 0x01234567, 0x456789AB))); TestUtils.AreEqual(int3(21, 17, 32), countbits(int3(-0x01234567, -0x456789AB, -1))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_int4() { TestUtils.AreEqual(int4(0, 12, 16, 21), countbits(int4(0, 0x01234567, 0x456789AB, -0x01234567))); TestUtils.AreEqual(int4(17, 32, 30, 29), countbits(int4(-0x456789AB, -1, -7, -15))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_uint() { TestUtils.AreEqual(0, countbits(0u)); @@ -66,7 +66,7 @@ public static void countbits_uint() TestUtils.AreEqual(32, countbits(0xFFFFFFFFu)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_uint2() { TestUtils.AreEqual(int2(0, 12), countbits(uint2(0, 0x01234567))); @@ -74,21 +74,21 @@ public static void countbits_uint2() TestUtils.AreEqual(int2(16, 32), countbits(uint2(0xCDEF0123u, 0xFFFFFFFFu))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_uint3() { TestUtils.AreEqual(int3(0, 12, 16), countbits(uint3(0, 0x01234567, 0x456789AB))); TestUtils.AreEqual(int3(20, 16, 32), countbits(uint3(0x89ABCDEFu, 0xCDEF0123u, 0xFFFFFFFFu))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_uint4() { TestUtils.AreEqual(int4(0, 12, 16, 20), countbits(uint4(0, 0x01234567, 0x456789AB, 0x89ABCDEFu))); TestUtils.AreEqual(int4(16, 32, 30, 29), countbits(uint4(0xCDEF0123u, 0xFFFFFFFFu, 0xFFFFFFF5u, 0xFFFFFFF1u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_long() { TestUtils.AreEqual(0, countbits(0L)); @@ -97,7 +97,7 @@ public static void countbits_long() TestUtils.AreEqual(64, countbits(-1L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void countbits_ulong() { TestUtils.AreEqual(0, countbits(0UL)); @@ -106,7 +106,7 @@ public static void countbits_ulong() TestUtils.AreEqual(64, countbits(0xFFFFFFFFFFFFFFFFUL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_int() { TestUtils.AreEqual(32, lzcnt(0)); @@ -119,7 +119,7 @@ public static void lzcnt_int() TestUtils.AreEqual(0, lzcnt(-2147483648)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_int2() { TestUtils.AreEqual(int2(32, 31), lzcnt(int2(0, 1))); @@ -128,7 +128,7 @@ public static void lzcnt_int2() TestUtils.AreEqual(int2(0, 0), lzcnt(int2(-1, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_int3() { TestUtils.AreEqual(int3(32, 31, 30), lzcnt(int3(0, 1, 2))); @@ -136,14 +136,14 @@ public static void lzcnt_int3() TestUtils.AreEqual(int3(0, 0, 27), lzcnt(int3(-1, -2147483648, 17))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_int4() { TestUtils.AreEqual(int4(32, 31, 30, 30), lzcnt(int4(0, 1, 2, 3))); TestUtils.AreEqual(int4(17, 5, 0, 0), lzcnt(int4(0x5321, 0x04435321, -1, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_uint() { TestUtils.AreEqual(32, lzcnt(0u)); @@ -156,7 +156,7 @@ public static void lzcnt_uint() TestUtils.AreEqual(0, lzcnt(0xFFFFFFFFu)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_uint2() { TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u))); @@ -165,7 +165,7 @@ public static void lzcnt_uint2() TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_uint3() { TestUtils.AreEqual(int3(32, 31, 30), lzcnt(uint3(0u, 1u, 2u))); @@ -173,7 +173,7 @@ public static void lzcnt_uint3() TestUtils.AreEqual(int3(0, 0, 27), lzcnt(uint3(0x84435320u, 0xFFFFFFFFu, 17))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_uint4() { TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u))); @@ -182,7 +182,7 @@ public static void lzcnt_uint4() TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_long() { TestUtils.AreEqual(64, lzcnt(0L)); @@ -194,7 +194,7 @@ public static void lzcnt_long() TestUtils.AreEqual(0, lzcnt(-9223372036854775808L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lzcnt_ulong() { TestUtils.AreEqual(64, lzcnt(0UL)); @@ -206,7 +206,7 @@ public static void lzcnt_ulong() TestUtils.AreEqual(0, lzcnt(0x8000000000000000UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_int() { TestUtils.AreEqual(32, tzcnt(0)); @@ -220,7 +220,7 @@ public static void tzcnt_int() TestUtils.AreEqual(31, tzcnt(-2147483648)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_int2() { TestUtils.AreEqual(int2(32, 0), tzcnt(int2(0, 1))); @@ -230,7 +230,7 @@ public static void tzcnt_int2() TestUtils.AreEqual(int2(31, 2), tzcnt(int2(-2147483648, 20))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_int3() { TestUtils.AreEqual(int3(32, 0, 1), tzcnt(int3(0, 1, 2))); @@ -238,7 +238,7 @@ public static void tzcnt_int3() TestUtils.AreEqual(int3(1, 0, 31), tzcnt(int3(-2, -2147483647, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_int4() { TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(int4(0, 1, 2, 3))); @@ -246,7 +246,7 @@ public static void tzcnt_int4() TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(int4(-2147483648, 20, 4132, -8))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_uint() { TestUtils.AreEqual(32, tzcnt(0u)); @@ -260,7 +260,7 @@ public static void tzcnt_uint() TestUtils.AreEqual(31, tzcnt(0x80000000u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_uint2() { TestUtils.AreEqual(int2(32, 0), tzcnt(uint2(0u, 1u))); @@ -270,7 +270,7 @@ public static void tzcnt_uint2() TestUtils.AreEqual(int2(31, 2), tzcnt(uint2(0x80000000u, 20u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_uint3() { TestUtils.AreEqual(int3(32, 0, 1), tzcnt(uint3(0u, 1u, 2u))); @@ -278,7 +278,7 @@ public static void tzcnt_uint3() TestUtils.AreEqual(int3(1, 0, 31), tzcnt(uint3(0xFFFFFFFEu, 0x80000001u, 0x80000000u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_uint4() { TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(uint4(0u, 1u, 2u, 3u))); @@ -286,7 +286,7 @@ public static void tzcnt_uint4() TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(uint4(0x80000000u, 20u, 4132u, 0xFFFFFFF8u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_long() { TestUtils.AreEqual(64, tzcnt(0L)); @@ -298,7 +298,7 @@ public static void tzcnt_long() TestUtils.AreEqual(0, tzcnt(-9223372036854775807L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tzcnt_ulong() { TestUtils.AreEqual(64, tzcnt(0UL)); @@ -310,7 +310,7 @@ public static void tzcnt_ulong() TestUtils.AreEqual(0, tzcnt(0x8000000000000001UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_int() { TestUtils.AreEqual(0x03521609, reversebits(-1872213312)); @@ -319,27 +319,27 @@ public static void reversebits_int() TestUtils.AreEqual(0x48d9c42e, reversebits(0x74239b12)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_int2() { TestUtils.AreEqual(int2(0x03521609, 0x5f5b0648), reversebits(int2(-1872213312, 0x1260dafa))); TestUtils.AreEqual(int2(0x4bbafd8d, 0x48d9c42e), reversebits(int2(-1312858670, 0x74239b12))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_int3() { TestUtils.AreEqual(int3(0x03521609, 0x5f5b0648, 0x4bbafd8d), reversebits(int3(-1872213312, 0x1260dafa, -1312858670))); TestUtils.AreEqual(int3(0x48d9c42e, 0, -1), reversebits(int3(0x74239b12, 0, -1))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_int4() { TestUtils.AreEqual(int4(0x03521609, 0x5f5b0648, 0x4bbafd8d, 0x48d9c42e), reversebits(int4(-1872213312, 0x1260dafa, -1312858670, 0x74239b12))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_uint() { TestUtils.AreEqual(0x03521609u, reversebits(0x90684ac0u)); @@ -348,39 +348,39 @@ public static void reversebits_uint() TestUtils.AreEqual(0x48d9c42eu, reversebits(0x74239b12u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_uint2() { TestUtils.AreEqual(uint2(0x03521609u, 0x5f5b0648u), reversebits(uint2(0x90684ac0u, 0x1260dafau))); TestUtils.AreEqual(uint2(0x4bbafd8du, 0x48d9c42eu), reversebits(uint2(0xb1bf5dd2u, 0x74239b12u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_uint3() { TestUtils.AreEqual(uint3(0x03521609u, 0x5f5b0648u, 0x4bbafd8du), reversebits(uint3(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u))); TestUtils.AreEqual(uint3(0x48d9c42eu, 0u, 0xFFFFFFFF), reversebits(uint3(0x74239b12u, 0u, 0xFFFFFFFF))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_uint4() { TestUtils.AreEqual(uint4(0x03521609u, 0x5f5b0648u, 0x4bbafd8du, 0x48d9c42eu), reversebits(uint4(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u, 0x74239b12u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_long() { TestUtils.AreEqual(0x4bbafd8d5f5b0648L, reversebits(0x1260dafab1bf5dd2L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reversebits_ulong() { TestUtils.AreEqual(0x4bbafd8d5f5b0648ul, reversebits(0x1260dafab1bf5dd2ul)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_int() { TestUtils.AreEqual(-1933184920, rol(219257022, 11)); @@ -389,27 +389,27 @@ public static void rol_int() TestUtils.AreEqual(661621977, rol(-1692078607, 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_int2() { TestUtils.AreEqual(int2(-1933184920, -2048170741), rol(int2(219257022, -1586446996), 11)); TestUtils.AreEqual(int2(-1152739462, 661621977), rol(int2(-279484078, -1692078607), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_int3() { TestUtils.AreEqual(int3(-1933184920, -2048170741, -1152739462), rol(int3(219257022, -1586446996, -279484078), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_int4() { TestUtils.AreEqual(int4(-1933184920, -2048170741, -1152739462, 661621977), rol(int4(219257022, -1586446996, -279484078, -1692078607), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_uint() { TestUtils.AreEqual(2361782376u, rol(219257022u, 11)); @@ -418,27 +418,27 @@ public static void rol_uint() TestUtils.AreEqual(661621977u, rol(2602888689u, 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_uint2() { TestUtils.AreEqual(uint2(2361782376u, 2246796555u), rol(uint2(219257022u, 2708520300u), 11)); TestUtils.AreEqual(uint2(3142227834u, 661621977u), rol(uint2(4015483218u, 2602888689u), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_uint3() { TestUtils.AreEqual(uint3(2361782376u, 2246796555u, 3142227834u), rol(uint3(219257022u, 2708520300u, 4015483218u), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_uint4() { TestUtils.AreEqual(uint4(2361782376u, 2246796555u, 3142227834u, 661621977u), rol(uint4(219257022u, 2708520300u, 4015483218u, 2602888689u), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_long() { TestUtils.AreEqual(4769317691753349395L, rol(6894885722123239465L, 37)); @@ -447,7 +447,7 @@ public static void rol_long() TestUtils.AreEqual(-5493728106787075631L, rol(2788577329702376155L, 37)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rol_ulong() { TestUtils.AreEqual(4769317691753349395UL, rol(6894885722123239465UL, 37)); @@ -457,7 +457,7 @@ public static void rol_ulong() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_int() { TestUtils.AreEqual(87245360, ror(-1710129111, 11)); @@ -466,27 +466,27 @@ public static void ror_int() TestUtils.AreEqual(-232831845, ror(-98246768, 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_int2() { TestUtils.AreEqual(int2(87245360, -259445220), ror(int2(-1710129111, 1232136068), 11)); TestUtils.AreEqual(int2(-1697813787, -232831845), ror(int2(1800875222, -98246768), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_int3() { TestUtils.AreEqual(int3(87245360, -259445220, -1697813787), ror(int3(-1710129111, 1232136068, 1800875222), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_int4() { TestUtils.AreEqual(int4(87245360, -259445220, -1697813787, -232831845), ror(int4(-1710129111, 1232136068, 1800875222, -98246768), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_uint() { TestUtils.AreEqual(87245360u, ror(2584838185u, 11)); @@ -495,26 +495,26 @@ public static void ror_uint() TestUtils.AreEqual(4062135451u, ror(4196720528u, 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_uint2() { TestUtils.AreEqual(uint2(87245360u, 4035522076u), ror(uint2(2584838185u, 1232136068u), 11)); TestUtils.AreEqual(uint2(2597153509u, 4062135451u), ror(uint2(1800875222u, 4196720528u), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_uint3() { TestUtils.AreEqual(uint3(87245360u, 4035522076u, 2597153509u), ror(uint3(2584838185u, 1232136068u, 1800875222u), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_uint4() { TestUtils.AreEqual(uint4(87245360u, 4035522076u, 2597153509u, 4062135451u), ror(uint4(2584838185u, 1232136068u, 1800875222u, 4196720528u), 11)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_long() { TestUtils.AreEqual(4958617126915898480L, ror(6894885722123239465L, 37)); @@ -523,7 +523,7 @@ public static void ror_long() TestUtils.AreEqual(8389344736564320290L, ror(2788577329702376155L, 37)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ror_ulong() { TestUtils.AreEqual(4958617126915898480UL, ror(6894885722123239465UL, 37)); diff --git a/src/Tests/Tests/Shared/TestBool2.gen.cs b/src/Tests/Tests/Shared/TestBool2.gen.cs index fe9ee45c..11c32ff2 100644 --- a/src/Tests/Tests/Shared/TestBool2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_constructor() { bool2 a = new bool2(false, true); @@ -23,7 +23,7 @@ public static void bool2_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_scalar_constructor() { bool2 a = new bool2(true); @@ -31,7 +31,7 @@ public static void bool2_scalar_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_static_constructor() { bool2 a = bool2(false, true); @@ -39,7 +39,7 @@ public static void bool2_static_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_static_scalar_constructor() { bool2 a = bool2(true); @@ -47,7 +47,7 @@ public static void bool2_static_scalar_constructor() TestUtils.AreEqual(true, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_equal_wide_wide() { bool2 a0 = bool2(true, false); @@ -71,7 +71,7 @@ public static void bool2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_equal_wide_scalar() { bool2 a0 = bool2(false, true); @@ -95,7 +95,7 @@ public static void bool2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_equal_scalar_wide() { bool a0 = (false); @@ -119,7 +119,7 @@ public static void bool2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_not_equal_wide_wide() { bool2 a0 = bool2(true, true); @@ -143,7 +143,7 @@ public static void bool2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_not_equal_wide_scalar() { bool2 a0 = bool2(false, true); @@ -167,7 +167,7 @@ public static void bool2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -191,7 +191,7 @@ public static void bool2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_and_wide_wide() { bool2 a0 = bool2(false, false); @@ -215,7 +215,7 @@ public static void bool2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_and_wide_scalar() { bool2 a0 = bool2(true, false); @@ -239,7 +239,7 @@ public static void bool2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -263,7 +263,7 @@ public static void bool2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_or_wide_wide() { bool2 a0 = bool2(true, true); @@ -287,7 +287,7 @@ public static void bool2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_or_wide_scalar() { bool2 a0 = bool2(true, true); @@ -311,7 +311,7 @@ public static void bool2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -335,7 +335,7 @@ public static void bool2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_xor_wide_wide() { bool2 a0 = bool2(true, false); @@ -359,7 +359,7 @@ public static void bool2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_xor_wide_scalar() { bool2 a0 = bool2(false, false); @@ -383,7 +383,7 @@ public static void bool2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -407,7 +407,7 @@ public static void bool2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_operator_logical_not() { bool2 a0 = bool2(true, true); diff --git a/src/Tests/Tests/Shared/TestBool2x2.gen.cs b/src/Tests/Tests/Shared/TestBool2x2.gen.cs index af2bb68c..1646031c 100644 --- a/src/Tests/Tests/Shared/TestBool2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_equal_wide_wide() { bool2x2 a0 = bool2x2(true, false, true, false); @@ -39,7 +39,7 @@ public static void bool2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_equal_wide_scalar() { bool2x2 a0 = bool2x2(false, true, false, false); @@ -63,7 +63,7 @@ public static void bool2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_not_equal_wide_wide() { bool2x2 a0 = bool2x2(true, true, true, false); @@ -111,7 +111,7 @@ public static void bool2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_not_equal_wide_scalar() { bool2x2 a0 = bool2x2(false, true, false, true); @@ -135,7 +135,7 @@ public static void bool2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_and_wide_wide() { bool2x2 a0 = bool2x2(false, false, true, true); @@ -183,7 +183,7 @@ public static void bool2x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_and_wide_scalar() { bool2x2 a0 = bool2x2(true, false, false, true); @@ -207,7 +207,7 @@ public static void bool2x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool2x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_or_wide_wide() { bool2x2 a0 = bool2x2(true, true, true, false); @@ -255,7 +255,7 @@ public static void bool2x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_or_wide_scalar() { bool2x2 a0 = bool2x2(true, true, false, true); @@ -279,7 +279,7 @@ public static void bool2x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool2x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_xor_wide_wide() { bool2x2 a0 = bool2x2(true, false, false, true); @@ -327,7 +327,7 @@ public static void bool2x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_xor_wide_scalar() { bool2x2 a0 = bool2x2(false, false, true, true); @@ -351,7 +351,7 @@ public static void bool2x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool2x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x2_operator_logical_not() { bool2x2 a0 = bool2x2(true, true, false, false); diff --git a/src/Tests/Tests/Shared/TestBool2x3.gen.cs b/src/Tests/Tests/Shared/TestBool2x3.gen.cs index bf0f34d2..8157a008 100644 --- a/src/Tests/Tests/Shared/TestBool2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_equal_wide_wide() { bool2x3 a0 = bool2x3(true, false, true, false, false, true); @@ -39,7 +39,7 @@ public static void bool2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_equal_wide_scalar() { bool2x3 a0 = bool2x3(false, true, false, false, false, false); @@ -63,7 +63,7 @@ public static void bool2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_not_equal_wide_wide() { bool2x3 a0 = bool2x3(true, true, true, false, false, true); @@ -111,7 +111,7 @@ public static void bool2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_not_equal_wide_scalar() { bool2x3 a0 = bool2x3(false, true, false, true, true, false); @@ -135,7 +135,7 @@ public static void bool2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_and_wide_wide() { bool2x3 a0 = bool2x3(false, false, true, true, false, false); @@ -183,7 +183,7 @@ public static void bool2x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_and_wide_scalar() { bool2x3 a0 = bool2x3(true, false, false, true, true, false); @@ -207,7 +207,7 @@ public static void bool2x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool2x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_or_wide_wide() { bool2x3 a0 = bool2x3(true, true, true, false, true, false); @@ -255,7 +255,7 @@ public static void bool2x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_or_wide_scalar() { bool2x3 a0 = bool2x3(true, true, false, true, true, true); @@ -279,7 +279,7 @@ public static void bool2x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool2x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_xor_wide_wide() { bool2x3 a0 = bool2x3(true, false, false, true, false, false); @@ -327,7 +327,7 @@ public static void bool2x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_xor_wide_scalar() { bool2x3 a0 = bool2x3(false, false, true, true, false, false); @@ -351,7 +351,7 @@ public static void bool2x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool2x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x3_operator_logical_not() { bool2x3 a0 = bool2x3(true, true, false, false, true, false); diff --git a/src/Tests/Tests/Shared/TestBool2x4.gen.cs b/src/Tests/Tests/Shared/TestBool2x4.gen.cs index 3310b755..fdfdb454 100644 --- a/src/Tests/Tests/Shared/TestBool2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool2x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_equal_wide_wide() { bool2x4 a0 = bool2x4(true, false, true, false, false, true, false, false); @@ -39,7 +39,7 @@ public static void bool2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_equal_wide_scalar() { bool2x4 a0 = bool2x4(false, true, false, false, false, false, true, false); @@ -63,7 +63,7 @@ public static void bool2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_not_equal_wide_wide() { bool2x4 a0 = bool2x4(true, true, true, false, false, true, false, false); @@ -111,7 +111,7 @@ public static void bool2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_not_equal_wide_scalar() { bool2x4 a0 = bool2x4(false, true, false, true, true, false, false, false); @@ -135,7 +135,7 @@ public static void bool2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_and_wide_wide() { bool2x4 a0 = bool2x4(false, false, true, true, false, false, true, true); @@ -183,7 +183,7 @@ public static void bool2x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_and_wide_scalar() { bool2x4 a0 = bool2x4(true, false, false, true, true, false, false, false); @@ -207,7 +207,7 @@ public static void bool2x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool2x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_or_wide_wide() { bool2x4 a0 = bool2x4(true, true, true, false, true, false, true, true); @@ -255,7 +255,7 @@ public static void bool2x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_or_wide_scalar() { bool2x4 a0 = bool2x4(true, true, false, true, true, true, true, false); @@ -279,7 +279,7 @@ public static void bool2x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool2x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_xor_wide_wide() { bool2x4 a0 = bool2x4(true, false, false, true, false, false, false, true); @@ -327,7 +327,7 @@ public static void bool2x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_xor_wide_scalar() { bool2x4 a0 = bool2x4(false, false, true, true, false, false, false, false); @@ -351,7 +351,7 @@ public static void bool2x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool2x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2x4_operator_logical_not() { bool2x4 a0 = bool2x4(true, true, false, false, true, false, true, false); diff --git a/src/Tests/Tests/Shared/TestBool3.gen.cs b/src/Tests/Tests/Shared/TestBool3.gen.cs index d66353aa..ee345f1e 100644 --- a/src/Tests/Tests/Shared/TestBool3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_constructor() { bool3 a = new bool3(false, true, false); @@ -24,7 +24,7 @@ public static void bool3_constructor() TestUtils.AreEqual(false, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_scalar_constructor() { bool3 a = new bool3(true); @@ -33,7 +33,7 @@ public static void bool3_scalar_constructor() TestUtils.AreEqual(true, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_static_constructor() { bool3 a = bool3(false, true, false); @@ -42,7 +42,7 @@ public static void bool3_static_constructor() TestUtils.AreEqual(false, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_static_scalar_constructor() { bool3 a = bool3(true); @@ -51,7 +51,7 @@ public static void bool3_static_scalar_constructor() TestUtils.AreEqual(true, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_equal_wide_wide() { bool3 a0 = bool3(true, false, true); @@ -75,7 +75,7 @@ public static void bool3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_equal_wide_scalar() { bool3 a0 = bool3(false, true, false); @@ -99,7 +99,7 @@ public static void bool3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_equal_scalar_wide() { bool a0 = (false); @@ -123,7 +123,7 @@ public static void bool3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_not_equal_wide_wide() { bool3 a0 = bool3(true, true, true); @@ -147,7 +147,7 @@ public static void bool3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_not_equal_wide_scalar() { bool3 a0 = bool3(false, true, false); @@ -171,7 +171,7 @@ public static void bool3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -195,7 +195,7 @@ public static void bool3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_and_wide_wide() { bool3 a0 = bool3(false, false, true); @@ -219,7 +219,7 @@ public static void bool3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_and_wide_scalar() { bool3 a0 = bool3(true, false, false); @@ -243,7 +243,7 @@ public static void bool3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -267,7 +267,7 @@ public static void bool3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_or_wide_wide() { bool3 a0 = bool3(true, true, true); @@ -291,7 +291,7 @@ public static void bool3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_or_wide_scalar() { bool3 a0 = bool3(true, true, false); @@ -315,7 +315,7 @@ public static void bool3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -339,7 +339,7 @@ public static void bool3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_xor_wide_wide() { bool3 a0 = bool3(true, false, false); @@ -363,7 +363,7 @@ public static void bool3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_xor_wide_scalar() { bool3 a0 = bool3(false, false, true); @@ -387,7 +387,7 @@ public static void bool3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -411,7 +411,7 @@ public static void bool3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_operator_logical_not() { bool3 a0 = bool3(true, true, false); diff --git a/src/Tests/Tests/Shared/TestBool3x2.gen.cs b/src/Tests/Tests/Shared/TestBool3x2.gen.cs index 5be3fb7b..816c30fd 100644 --- a/src/Tests/Tests/Shared/TestBool3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_equal_wide_wide() { bool3x2 a0 = bool3x2(true, false, true, false, false, true); @@ -39,7 +39,7 @@ public static void bool3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_equal_wide_scalar() { bool3x2 a0 = bool3x2(false, true, false, false, false, false); @@ -63,7 +63,7 @@ public static void bool3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_not_equal_wide_wide() { bool3x2 a0 = bool3x2(true, true, true, false, false, true); @@ -111,7 +111,7 @@ public static void bool3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_not_equal_wide_scalar() { bool3x2 a0 = bool3x2(false, true, false, true, true, false); @@ -135,7 +135,7 @@ public static void bool3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_and_wide_wide() { bool3x2 a0 = bool3x2(false, false, true, true, false, false); @@ -183,7 +183,7 @@ public static void bool3x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_and_wide_scalar() { bool3x2 a0 = bool3x2(true, false, false, true, true, false); @@ -207,7 +207,7 @@ public static void bool3x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool3x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_or_wide_wide() { bool3x2 a0 = bool3x2(true, true, true, false, true, false); @@ -255,7 +255,7 @@ public static void bool3x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_or_wide_scalar() { bool3x2 a0 = bool3x2(true, true, false, true, true, true); @@ -279,7 +279,7 @@ public static void bool3x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool3x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_xor_wide_wide() { bool3x2 a0 = bool3x2(true, false, false, true, false, false); @@ -327,7 +327,7 @@ public static void bool3x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_xor_wide_scalar() { bool3x2 a0 = bool3x2(false, false, true, true, false, false); @@ -351,7 +351,7 @@ public static void bool3x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool3x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x2_operator_logical_not() { bool3x2 a0 = bool3x2(true, true, false, false, true, false); diff --git a/src/Tests/Tests/Shared/TestBool3x3.gen.cs b/src/Tests/Tests/Shared/TestBool3x3.gen.cs index 4541a352..6c5b1b9b 100644 --- a/src/Tests/Tests/Shared/TestBool3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_equal_wide_wide() { bool3x3 a0 = bool3x3(true, false, true, false, false, true, false, false, true); @@ -39,7 +39,7 @@ public static void bool3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_equal_wide_scalar() { bool3x3 a0 = bool3x3(false, true, false, false, false, false, true, false, false); @@ -63,7 +63,7 @@ public static void bool3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_not_equal_wide_wide() { bool3x3 a0 = bool3x3(true, true, true, false, false, true, false, false, false); @@ -111,7 +111,7 @@ public static void bool3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_not_equal_wide_scalar() { bool3x3 a0 = bool3x3(false, true, false, true, true, false, false, false, false); @@ -135,7 +135,7 @@ public static void bool3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_and_wide_wide() { bool3x3 a0 = bool3x3(false, false, true, true, false, false, true, true, true); @@ -183,7 +183,7 @@ public static void bool3x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_and_wide_scalar() { bool3x3 a0 = bool3x3(true, false, false, true, true, false, false, false, false); @@ -207,7 +207,7 @@ public static void bool3x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool3x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_or_wide_wide() { bool3x3 a0 = bool3x3(true, true, true, false, true, false, true, true, false); @@ -255,7 +255,7 @@ public static void bool3x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_or_wide_scalar() { bool3x3 a0 = bool3x3(true, true, false, true, true, true, true, false, true); @@ -279,7 +279,7 @@ public static void bool3x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool3x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_xor_wide_wide() { bool3x3 a0 = bool3x3(true, false, false, true, false, false, false, true, false); @@ -327,7 +327,7 @@ public static void bool3x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_xor_wide_scalar() { bool3x3 a0 = bool3x3(false, false, true, true, false, false, false, false, false); @@ -351,7 +351,7 @@ public static void bool3x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool3x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x3_operator_logical_not() { bool3x3 a0 = bool3x3(true, true, false, false, true, false, true, false, true); diff --git a/src/Tests/Tests/Shared/TestBool3x4.gen.cs b/src/Tests/Tests/Shared/TestBool3x4.gen.cs index 02565c51..8d7d6245 100644 --- a/src/Tests/Tests/Shared/TestBool3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool3x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_equal_wide_wide() { bool3x4 a0 = bool3x4(true, false, true, false, false, true, false, false, true, false, true, false); @@ -39,7 +39,7 @@ public static void bool3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_equal_wide_scalar() { bool3x4 a0 = bool3x4(false, true, false, false, false, false, true, false, false, false, true, true); @@ -63,7 +63,7 @@ public static void bool3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_not_equal_wide_wide() { bool3x4 a0 = bool3x4(true, true, true, false, false, true, false, false, false, false, true, true); @@ -111,7 +111,7 @@ public static void bool3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_not_equal_wide_scalar() { bool3x4 a0 = bool3x4(false, true, false, true, true, false, false, false, false, false, false, false); @@ -135,7 +135,7 @@ public static void bool3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_and_wide_wide() { bool3x4 a0 = bool3x4(false, false, true, true, false, false, true, true, true, false, true, true); @@ -183,7 +183,7 @@ public static void bool3x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_and_wide_scalar() { bool3x4 a0 = bool3x4(true, false, false, true, true, false, false, false, false, false, true, true); @@ -207,7 +207,7 @@ public static void bool3x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool3x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_or_wide_wide() { bool3x4 a0 = bool3x4(true, true, true, false, true, false, true, true, false, true, true, true); @@ -255,7 +255,7 @@ public static void bool3x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_or_wide_scalar() { bool3x4 a0 = bool3x4(true, true, false, true, true, true, true, false, true, false, false, true); @@ -279,7 +279,7 @@ public static void bool3x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool3x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_xor_wide_wide() { bool3x4 a0 = bool3x4(true, false, false, true, false, false, false, true, false, false, true, true); @@ -327,7 +327,7 @@ public static void bool3x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_xor_wide_scalar() { bool3x4 a0 = bool3x4(false, false, true, true, false, false, false, false, false, false, false, true); @@ -351,7 +351,7 @@ public static void bool3x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool3x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3x4_operator_logical_not() { bool3x4 a0 = bool3x4(true, true, false, false, true, false, true, false, true, false, false, false); diff --git a/src/Tests/Tests/Shared/TestBool4.gen.cs b/src/Tests/Tests/Shared/TestBool4.gen.cs index 4faf4e36..c2c8be05 100644 --- a/src/Tests/Tests/Shared/TestBool4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_constructor() { bool4 a = new bool4(false, true, false, true); @@ -25,7 +25,7 @@ public static void bool4_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_scalar_constructor() { bool4 a = new bool4(true); @@ -35,7 +35,7 @@ public static void bool4_scalar_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_static_constructor() { bool4 a = bool4(false, true, false, true); @@ -45,7 +45,7 @@ public static void bool4_static_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_static_scalar_constructor() { bool4 a = bool4(true); @@ -55,7 +55,7 @@ public static void bool4_static_scalar_constructor() TestUtils.AreEqual(true, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_equal_wide_wide() { bool4 a0 = bool4(true, false, true, false); @@ -79,7 +79,7 @@ public static void bool4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_equal_wide_scalar() { bool4 a0 = bool4(false, true, false, false); @@ -103,7 +103,7 @@ public static void bool4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_equal_scalar_wide() { bool a0 = (false); @@ -127,7 +127,7 @@ public static void bool4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_not_equal_wide_wide() { bool4 a0 = bool4(true, true, true, false); @@ -151,7 +151,7 @@ public static void bool4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_not_equal_wide_scalar() { bool4 a0 = bool4(false, true, false, true); @@ -175,7 +175,7 @@ public static void bool4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -199,7 +199,7 @@ public static void bool4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_and_wide_wide() { bool4 a0 = bool4(false, false, true, true); @@ -223,7 +223,7 @@ public static void bool4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_and_wide_scalar() { bool4 a0 = bool4(true, false, false, true); @@ -247,7 +247,7 @@ public static void bool4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -271,7 +271,7 @@ public static void bool4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_or_wide_wide() { bool4 a0 = bool4(true, true, true, false); @@ -295,7 +295,7 @@ public static void bool4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_or_wide_scalar() { bool4 a0 = bool4(true, true, false, true); @@ -319,7 +319,7 @@ public static void bool4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -343,7 +343,7 @@ public static void bool4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_xor_wide_wide() { bool4 a0 = bool4(true, false, false, true); @@ -367,7 +367,7 @@ public static void bool4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_xor_wide_scalar() { bool4 a0 = bool4(false, false, true, true); @@ -391,7 +391,7 @@ public static void bool4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -415,7 +415,7 @@ public static void bool4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_operator_logical_not() { bool4 a0 = bool4(true, true, false, false); diff --git a/src/Tests/Tests/Shared/TestBool4x2.gen.cs b/src/Tests/Tests/Shared/TestBool4x2.gen.cs index b7585d45..40511294 100644 --- a/src/Tests/Tests/Shared/TestBool4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_equal_wide_wide() { bool4x2 a0 = bool4x2(true, false, true, false, false, true, false, false); @@ -39,7 +39,7 @@ public static void bool4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_equal_wide_scalar() { bool4x2 a0 = bool4x2(false, true, false, false, false, false, true, false); @@ -63,7 +63,7 @@ public static void bool4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_not_equal_wide_wide() { bool4x2 a0 = bool4x2(true, true, true, false, false, true, false, false); @@ -111,7 +111,7 @@ public static void bool4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_not_equal_wide_scalar() { bool4x2 a0 = bool4x2(false, true, false, true, true, false, false, false); @@ -135,7 +135,7 @@ public static void bool4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_and_wide_wide() { bool4x2 a0 = bool4x2(false, false, true, true, false, false, true, true); @@ -183,7 +183,7 @@ public static void bool4x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_and_wide_scalar() { bool4x2 a0 = bool4x2(true, false, false, true, true, false, false, false); @@ -207,7 +207,7 @@ public static void bool4x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool4x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_or_wide_wide() { bool4x2 a0 = bool4x2(true, true, true, false, true, false, true, true); @@ -255,7 +255,7 @@ public static void bool4x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_or_wide_scalar() { bool4x2 a0 = bool4x2(true, true, false, true, true, true, true, false); @@ -279,7 +279,7 @@ public static void bool4x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool4x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_xor_wide_wide() { bool4x2 a0 = bool4x2(true, false, false, true, false, false, false, true); @@ -327,7 +327,7 @@ public static void bool4x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_xor_wide_scalar() { bool4x2 a0 = bool4x2(false, false, true, true, false, false, false, false); @@ -351,7 +351,7 @@ public static void bool4x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool4x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x2_operator_logical_not() { bool4x2 a0 = bool4x2(true, true, false, false, true, false, true, false); diff --git a/src/Tests/Tests/Shared/TestBool4x3.gen.cs b/src/Tests/Tests/Shared/TestBool4x3.gen.cs index 012ad7e5..ea0d9fe2 100644 --- a/src/Tests/Tests/Shared/TestBool4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_equal_wide_wide() { bool4x3 a0 = bool4x3(true, false, true, false, false, true, false, false, true, false, true, false); @@ -39,7 +39,7 @@ public static void bool4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_equal_wide_scalar() { bool4x3 a0 = bool4x3(false, true, false, false, false, false, true, false, false, false, true, true); @@ -63,7 +63,7 @@ public static void bool4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_not_equal_wide_wide() { bool4x3 a0 = bool4x3(true, true, true, false, false, true, false, false, false, false, true, true); @@ -111,7 +111,7 @@ public static void bool4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_not_equal_wide_scalar() { bool4x3 a0 = bool4x3(false, true, false, true, true, false, false, false, false, false, false, false); @@ -135,7 +135,7 @@ public static void bool4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_and_wide_wide() { bool4x3 a0 = bool4x3(false, false, true, true, false, false, true, true, true, false, true, true); @@ -183,7 +183,7 @@ public static void bool4x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_and_wide_scalar() { bool4x3 a0 = bool4x3(true, false, false, true, true, false, false, false, false, false, true, true); @@ -207,7 +207,7 @@ public static void bool4x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool4x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_or_wide_wide() { bool4x3 a0 = bool4x3(true, true, true, false, true, false, true, true, false, true, true, true); @@ -255,7 +255,7 @@ public static void bool4x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_or_wide_scalar() { bool4x3 a0 = bool4x3(true, true, false, true, true, true, true, false, true, false, false, true); @@ -279,7 +279,7 @@ public static void bool4x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool4x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_xor_wide_wide() { bool4x3 a0 = bool4x3(true, false, false, true, false, false, false, true, false, false, true, true); @@ -327,7 +327,7 @@ public static void bool4x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_xor_wide_scalar() { bool4x3 a0 = bool4x3(false, false, true, true, false, false, false, false, false, false, false, true); @@ -351,7 +351,7 @@ public static void bool4x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool4x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x3_operator_logical_not() { bool4x3 a0 = bool4x3(true, true, false, false, true, false, true, false, true, false, false, false); diff --git a/src/Tests/Tests/Shared/TestBool4x4.gen.cs b/src/Tests/Tests/Shared/TestBool4x4.gen.cs index 9cb7e412..11b5e424 100644 --- a/src/Tests/Tests/Shared/TestBool4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestBool4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestBool4x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_equal_wide_wide() { bool4x4 a0 = bool4x4(true, false, true, false, false, true, false, false, true, false, true, false, true, true, false, true); @@ -39,7 +39,7 @@ public static void bool4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_equal_wide_scalar() { bool4x4 a0 = bool4x4(false, true, false, false, false, false, true, false, false, false, true, true, false, true, false, true); @@ -63,7 +63,7 @@ public static void bool4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_equal_scalar_wide() { bool a0 = (false); @@ -87,7 +87,7 @@ public static void bool4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_not_equal_wide_wide() { bool4x4 a0 = bool4x4(true, true, true, false, false, true, false, false, false, false, true, true, true, true, true, true); @@ -111,7 +111,7 @@ public static void bool4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_not_equal_wide_scalar() { bool4x4 a0 = bool4x4(false, true, false, true, true, false, false, false, false, false, false, false, false, true, false, false); @@ -135,7 +135,7 @@ public static void bool4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_not_equal_scalar_wide() { bool a0 = (true); @@ -159,7 +159,7 @@ public static void bool4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_and_wide_wide() { bool4x4 a0 = bool4x4(false, false, true, true, false, false, true, true, true, false, true, true, true, true, false, false); @@ -183,7 +183,7 @@ public static void bool4x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_and_wide_scalar() { bool4x4 a0 = bool4x4(true, false, false, true, true, false, false, false, false, false, true, true, true, false, false, true); @@ -207,7 +207,7 @@ public static void bool4x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_and_scalar_wide() { bool a0 = (false); @@ -231,7 +231,7 @@ public static void bool4x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_or_wide_wide() { bool4x4 a0 = bool4x4(true, true, true, false, true, false, true, true, false, true, true, true, true, true, true, false); @@ -255,7 +255,7 @@ public static void bool4x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_or_wide_scalar() { bool4x4 a0 = bool4x4(true, true, false, true, true, true, true, false, true, false, false, true, false, false, true, false); @@ -279,7 +279,7 @@ public static void bool4x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_or_scalar_wide() { bool a0 = (true); @@ -303,7 +303,7 @@ public static void bool4x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_xor_wide_wide() { bool4x4 a0 = bool4x4(true, false, false, true, false, false, false, true, false, false, true, true, false, false, true, false); @@ -327,7 +327,7 @@ public static void bool4x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_xor_wide_scalar() { bool4x4 a0 = bool4x4(false, false, true, true, false, false, false, false, false, false, false, true, false, true, true, true); @@ -351,7 +351,7 @@ public static void bool4x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_bitwise_xor_scalar_wide() { bool a0 = (true); @@ -375,7 +375,7 @@ public static void bool4x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4x4_operator_logical_not() { bool4x4 a0 = bool4x4(true, true, false, false, true, false, true, false, true, false, false, false, false, true, true, false); diff --git a/src/Tests/Tests/Shared/TestDouble2.gen.cs b/src/Tests/Tests/Shared/TestDouble2.gen.cs index 30a3f849..f07b51f5 100644 --- a/src/Tests/Tests/Shared/TestDouble2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_zero() { TestUtils.AreEqual(0.0, double2.zero.x); TestUtils.AreEqual(0.0, double2.zero.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_constructor() { double2 a = new double2(1, 2); @@ -30,7 +30,7 @@ public static void double2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_scalar_constructor() { double2 a = new double2(17.0); @@ -38,7 +38,7 @@ public static void double2_scalar_constructor() TestUtils.AreEqual(17.0, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_static_constructor() { double2 a = double2(1, 2); @@ -46,7 +46,7 @@ public static void double2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_static_scalar_constructor() { double2 a = double2(17.0); @@ -54,7 +54,7 @@ public static void double2_static_scalar_constructor() TestUtils.AreEqual(17.0, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_equal_wide_wide() { double2 a0 = double2(492.15758275061728, -495.20632027797694); @@ -78,7 +78,7 @@ public static void double2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_equal_wide_scalar() { double2 a0 = double2(-303.2300766926399, 451.52631327674089); @@ -102,7 +102,7 @@ public static void double2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -126,7 +126,7 @@ public static void double2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_not_equal_wide_wide() { double2 a0 = double2(430.8425316432689, 104.69001798736394); @@ -150,7 +150,7 @@ public static void double2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_not_equal_wide_scalar() { double2 a0 = double2(-16.914588697680529, 168.83411486858233); @@ -174,7 +174,7 @@ public static void double2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -198,7 +198,7 @@ public static void double2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_less_wide_wide() { double2 a0 = double2(196.84256825076534, 336.40979997087732); @@ -222,7 +222,7 @@ public static void double2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_less_wide_scalar() { double2 a0 = double2(-132.05731708000292, -192.46500477216438); @@ -246,7 +246,7 @@ public static void double2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -270,7 +270,7 @@ public static void double2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_greater_wide_wide() { double2 a0 = double2(483.50140141113729, 310.81563415695712); @@ -294,7 +294,7 @@ public static void double2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_greater_wide_scalar() { double2 a0 = double2(64.317918092160426, -397.70346445483318); @@ -318,7 +318,7 @@ public static void double2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -342,7 +342,7 @@ public static void double2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_less_equal_wide_wide() { double2 a0 = double2(-438.52313753521219, 210.48942837980087); @@ -366,7 +366,7 @@ public static void double2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_less_equal_wide_scalar() { double2 a0 = double2(193.4958237118534, 168.91555197952107); @@ -390,7 +390,7 @@ public static void double2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -414,7 +414,7 @@ public static void double2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_greater_equal_wide_wide() { double2 a0 = double2(-507.92858409692, 504.49748181947393); @@ -438,7 +438,7 @@ public static void double2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_greater_equal_wide_scalar() { double2 a0 = double2(465.15218732559686, -424.8860745024337); @@ -462,7 +462,7 @@ public static void double2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -486,7 +486,7 @@ public static void double2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_add_wide_wide() { double2 a0 = double2(506.12905263627374, -501.77980803967444); @@ -510,7 +510,7 @@ public static void double2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_add_wide_scalar() { double2 a0 = double2(-194.51420387742769, 338.54838696985894); @@ -534,7 +534,7 @@ public static void double2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -558,7 +558,7 @@ public static void double2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_sub_wide_wide() { double2 a0 = double2(160.4922617229131, 11.223957305412682); @@ -582,7 +582,7 @@ public static void double2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_sub_wide_scalar() { double2 a0 = double2(207.38960108877609, 248.45773684627272); @@ -606,7 +606,7 @@ public static void double2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -630,7 +630,7 @@ public static void double2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_mul_wide_wide() { double2 a0 = double2(-482.71381710596097, -407.29348559272171); @@ -654,7 +654,7 @@ public static void double2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_mul_wide_scalar() { double2 a0 = double2(-96.318821236639678, -277.14229239017811); @@ -678,7 +678,7 @@ public static void double2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -702,7 +702,7 @@ public static void double2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_div_wide_wide() { double2 a0 = double2(-353.13144390337703, -102.79985456485292); @@ -726,7 +726,7 @@ public static void double2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_div_wide_scalar() { double2 a0 = double2(171.34242184988341, 0.10338377957384637); @@ -750,7 +750,7 @@ public static void double2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -774,7 +774,7 @@ public static void double2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_mod_wide_wide() { double2 a0 = double2(-388.81249422059045, 181.68118842955732); @@ -798,7 +798,7 @@ public static void double2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_mod_wide_scalar() { double2 a0 = double2(-244.49962889612635, -211.81931958525411); @@ -822,7 +822,7 @@ public static void double2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -846,7 +846,7 @@ public static void double2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_plus() { double2 a0 = double2(-418.82956357432045, -405.79894823851015); @@ -866,7 +866,7 @@ public static void double2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_neg() { double2 a0 = double2(148.46174890755753, -467.12267873581624); @@ -886,7 +886,7 @@ public static void double2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_prefix_inc() { double2 a0 = double2(-139.84208137348389, -56.743654039103376); @@ -906,7 +906,7 @@ public static void double2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_postfix_inc() { double2 a0 = double2(-396.6697396695007, 511.20749378167443); @@ -926,7 +926,7 @@ public static void double2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_prefix_dec() { double2 a0 = double2(123.12869626056806, 256.8437465433235); @@ -946,7 +946,7 @@ public static void double2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_operator_postfix_dec() { double2 a0 = double2(379.68831723727669, 302.69287814884115); @@ -966,7 +966,7 @@ public static void double2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_shuffle_result_1() { double2 a = double2(0, 1); @@ -978,7 +978,7 @@ public static void double2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_shuffle_result_2() { double2 a = double2(0, 1); @@ -1002,7 +1002,7 @@ public static void double2_shuffle_result_2() TestUtils.AreEqual(double2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_shuffle_result_3() { double2 a = double2(0, 1); @@ -1026,7 +1026,7 @@ public static void double2_shuffle_result_3() TestUtils.AreEqual(double3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_shuffle_result_4() { double2 a = double2(0, 1); diff --git a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs index 5531de5f..5b035267 100644 --- a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_zero() { TestUtils.AreEqual(0.0, double2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void double2x2_zero() TestUtils.AreEqual(0.0, double2x2.zero.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_identity() { TestUtils.AreEqual(1.0, double2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void double2x2_identity() TestUtils.AreEqual(1.0, double2x2.identity.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_equal_wide_wide() { double2x2 a0 = double2x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182); @@ -57,7 +57,7 @@ public static void double2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_equal_wide_scalar() { double2x2 a0 = double2x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995); @@ -81,7 +81,7 @@ public static void double2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -105,7 +105,7 @@ public static void double2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_not_equal_wide_wide() { double2x2 a0 = double2x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048); @@ -129,7 +129,7 @@ public static void double2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_not_equal_wide_scalar() { double2x2 a0 = double2x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137); @@ -153,7 +153,7 @@ public static void double2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -177,7 +177,7 @@ public static void double2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_less_wide_wide() { double2x2 a0 = double2x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963); @@ -201,7 +201,7 @@ public static void double2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_less_wide_scalar() { double2x2 a0 = double2x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561); @@ -225,7 +225,7 @@ public static void double2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -249,7 +249,7 @@ public static void double2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_greater_wide_wide() { double2x2 a0 = double2x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671); @@ -273,7 +273,7 @@ public static void double2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_greater_wide_scalar() { double2x2 a0 = double2x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157); @@ -297,7 +297,7 @@ public static void double2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -321,7 +321,7 @@ public static void double2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_less_equal_wide_wide() { double2x2 a0 = double2x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857); @@ -345,7 +345,7 @@ public static void double2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_less_equal_wide_scalar() { double2x2 a0 = double2x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292); @@ -369,7 +369,7 @@ public static void double2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -393,7 +393,7 @@ public static void double2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_greater_equal_wide_wide() { double2x2 a0 = double2x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784); @@ -417,7 +417,7 @@ public static void double2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_greater_equal_wide_scalar() { double2x2 a0 = double2x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356); @@ -441,7 +441,7 @@ public static void double2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -465,7 +465,7 @@ public static void double2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_add_wide_wide() { double2x2 a0 = double2x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274); @@ -489,7 +489,7 @@ public static void double2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_add_wide_scalar() { double2x2 a0 = double2x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752); @@ -513,7 +513,7 @@ public static void double2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -537,7 +537,7 @@ public static void double2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_sub_wide_wide() { double2x2 a0 = double2x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311); @@ -561,7 +561,7 @@ public static void double2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_sub_wide_scalar() { double2x2 a0 = double2x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506); @@ -585,7 +585,7 @@ public static void double2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -609,7 +609,7 @@ public static void double2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_mul_wide_wide() { double2x2 a0 = double2x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182); @@ -633,7 +633,7 @@ public static void double2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_mul_wide_scalar() { double2x2 a0 = double2x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409); @@ -657,7 +657,7 @@ public static void double2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -681,7 +681,7 @@ public static void double2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_div_wide_wide() { double2x2 a0 = double2x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176); @@ -705,7 +705,7 @@ public static void double2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_div_wide_scalar() { double2x2 a0 = double2x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078); @@ -729,7 +729,7 @@ public static void double2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -753,7 +753,7 @@ public static void double2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_mod_wide_wide() { double2x2 a0 = double2x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813); @@ -777,7 +777,7 @@ public static void double2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_mod_wide_scalar() { double2x2 a0 = double2x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672); @@ -801,7 +801,7 @@ public static void double2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -825,7 +825,7 @@ public static void double2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_plus() { double2x2 a0 = double2x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421); @@ -845,7 +845,7 @@ public static void double2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_neg() { double2x2 a0 = double2x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463); @@ -865,7 +865,7 @@ public static void double2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_prefix_inc() { double2x2 a0 = double2x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962); @@ -885,7 +885,7 @@ public static void double2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_postfix_inc() { double2x2 a0 = double2x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153); @@ -905,7 +905,7 @@ public static void double2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_prefix_dec() { double2x2 a0 = double2x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563); @@ -925,7 +925,7 @@ public static void double2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x2_operator_postfix_dec() { double2x2 a0 = double2x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962); diff --git a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs index 20df3853..0b5cb5cf 100644 --- a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_zero() { TestUtils.AreEqual(0.0, double2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void double2x3_zero() TestUtils.AreEqual(0.0, double2x3.zero.c2.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_equal_wide_wide() { double2x3 a0 = double2x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749); @@ -50,7 +50,7 @@ public static void double2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_equal_wide_scalar() { double2x3 a0 = double2x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315); @@ -74,7 +74,7 @@ public static void double2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -98,7 +98,7 @@ public static void double2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_not_equal_wide_wide() { double2x3 a0 = double2x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379); @@ -122,7 +122,7 @@ public static void double2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_not_equal_wide_scalar() { double2x3 a0 = double2x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959); @@ -146,7 +146,7 @@ public static void double2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -170,7 +170,7 @@ public static void double2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_less_wide_wide() { double2x3 a0 = double2x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774); @@ -194,7 +194,7 @@ public static void double2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_less_wide_scalar() { double2x3 a0 = double2x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879); @@ -218,7 +218,7 @@ public static void double2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -242,7 +242,7 @@ public static void double2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_greater_wide_wide() { double2x3 a0 = double2x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479); @@ -266,7 +266,7 @@ public static void double2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_greater_wide_scalar() { double2x3 a0 = double2x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809); @@ -290,7 +290,7 @@ public static void double2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -314,7 +314,7 @@ public static void double2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_less_equal_wide_wide() { double2x3 a0 = double2x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475); @@ -338,7 +338,7 @@ public static void double2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_less_equal_wide_scalar() { double2x3 a0 = double2x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136); @@ -362,7 +362,7 @@ public static void double2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -386,7 +386,7 @@ public static void double2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_greater_equal_wide_wide() { double2x3 a0 = double2x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193); @@ -410,7 +410,7 @@ public static void double2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_greater_equal_wide_scalar() { double2x3 a0 = double2x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976); @@ -434,7 +434,7 @@ public static void double2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -458,7 +458,7 @@ public static void double2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_add_wide_wide() { double2x3 a0 = double2x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056); @@ -482,7 +482,7 @@ public static void double2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_add_wide_scalar() { double2x3 a0 = double2x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166); @@ -506,7 +506,7 @@ public static void double2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -530,7 +530,7 @@ public static void double2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_sub_wide_wide() { double2x3 a0 = double2x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053); @@ -554,7 +554,7 @@ public static void double2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_sub_wide_scalar() { double2x3 a0 = double2x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896); @@ -578,7 +578,7 @@ public static void double2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -602,7 +602,7 @@ public static void double2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_mul_wide_wide() { double2x3 a0 = double2x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747); @@ -626,7 +626,7 @@ public static void double2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_mul_wide_scalar() { double2x3 a0 = double2x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229); @@ -650,7 +650,7 @@ public static void double2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -674,7 +674,7 @@ public static void double2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_div_wide_wide() { double2x3 a0 = double2x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758); @@ -698,7 +698,7 @@ public static void double2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_div_wide_scalar() { double2x3 a0 = double2x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509); @@ -722,7 +722,7 @@ public static void double2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -746,7 +746,7 @@ public static void double2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_mod_wide_wide() { double2x3 a0 = double2x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406); @@ -770,7 +770,7 @@ public static void double2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_mod_wide_scalar() { double2x3 a0 = double2x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221); @@ -794,7 +794,7 @@ public static void double2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -818,7 +818,7 @@ public static void double2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_plus() { double2x3 a0 = double2x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287); @@ -838,7 +838,7 @@ public static void double2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_neg() { double2x3 a0 = double2x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605); @@ -858,7 +858,7 @@ public static void double2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_prefix_inc() { double2x3 a0 = double2x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198); @@ -878,7 +878,7 @@ public static void double2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_postfix_inc() { double2x3 a0 = double2x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219); @@ -898,7 +898,7 @@ public static void double2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_prefix_dec() { double2x3 a0 = double2x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339); @@ -918,7 +918,7 @@ public static void double2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x3_operator_postfix_dec() { double2x3 a0 = double2x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231); diff --git a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs index 822a43bb..c519d6f4 100644 --- a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble2x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_zero() { TestUtils.AreEqual(0.0, double2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void double2x4_zero() TestUtils.AreEqual(0.0, double2x4.zero.c3.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_equal_wide_wide() { double2x4 a0 = double2x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889); @@ -52,7 +52,7 @@ public static void double2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_equal_wide_scalar() { double2x4 a0 = double2x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405); @@ -76,7 +76,7 @@ public static void double2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -100,7 +100,7 @@ public static void double2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_not_equal_wide_wide() { double2x4 a0 = double2x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895); @@ -124,7 +124,7 @@ public static void double2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_not_equal_wide_scalar() { double2x4 a0 = double2x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842); @@ -148,7 +148,7 @@ public static void double2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -172,7 +172,7 @@ public static void double2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_less_wide_wide() { double2x4 a0 = double2x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259); @@ -196,7 +196,7 @@ public static void double2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_less_wide_scalar() { double2x4 a0 = double2x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061); @@ -220,7 +220,7 @@ public static void double2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -244,7 +244,7 @@ public static void double2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_greater_wide_wide() { double2x4 a0 = double2x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484); @@ -268,7 +268,7 @@ public static void double2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_greater_wide_scalar() { double2x4 a0 = double2x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972); @@ -292,7 +292,7 @@ public static void double2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -316,7 +316,7 @@ public static void double2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_less_equal_wide_wide() { double2x4 a0 = double2x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232); @@ -340,7 +340,7 @@ public static void double2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_less_equal_wide_scalar() { double2x4 a0 = double2x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582); @@ -364,7 +364,7 @@ public static void double2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -388,7 +388,7 @@ public static void double2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_greater_equal_wide_wide() { double2x4 a0 = double2x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265); @@ -412,7 +412,7 @@ public static void double2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_greater_equal_wide_scalar() { double2x4 a0 = double2x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838); @@ -436,7 +436,7 @@ public static void double2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -460,7 +460,7 @@ public static void double2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_add_wide_wide() { double2x4 a0 = double2x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656); @@ -484,7 +484,7 @@ public static void double2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_add_wide_scalar() { double2x4 a0 = double2x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454); @@ -508,7 +508,7 @@ public static void double2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -532,7 +532,7 @@ public static void double2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_sub_wide_wide() { double2x4 a0 = double2x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537); @@ -556,7 +556,7 @@ public static void double2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_sub_wide_scalar() { double2x4 a0 = double2x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965); @@ -580,7 +580,7 @@ public static void double2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -604,7 +604,7 @@ public static void double2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_mul_wide_wide() { double2x4 a0 = double2x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149); @@ -628,7 +628,7 @@ public static void double2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_mul_wide_scalar() { double2x4 a0 = double2x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334); @@ -652,7 +652,7 @@ public static void double2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -676,7 +676,7 @@ public static void double2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_div_wide_wide() { double2x4 a0 = double2x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537); @@ -700,7 +700,7 @@ public static void double2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_div_wide_scalar() { double2x4 a0 = double2x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539); @@ -724,7 +724,7 @@ public static void double2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -748,7 +748,7 @@ public static void double2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_mod_wide_wide() { double2x4 a0 = double2x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664); @@ -772,7 +772,7 @@ public static void double2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_mod_wide_scalar() { double2x4 a0 = double2x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243); @@ -796,7 +796,7 @@ public static void double2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -820,7 +820,7 @@ public static void double2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_plus() { double2x4 a0 = double2x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488); @@ -840,7 +840,7 @@ public static void double2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_neg() { double2x4 a0 = double2x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581); @@ -860,7 +860,7 @@ public static void double2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_prefix_inc() { double2x4 a0 = double2x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267); @@ -880,7 +880,7 @@ public static void double2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_postfix_inc() { double2x4 a0 = double2x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271); @@ -900,7 +900,7 @@ public static void double2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_prefix_dec() { double2x4 a0 = double2x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558); @@ -920,7 +920,7 @@ public static void double2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2x4_operator_postfix_dec() { double2x4 a0 = double2x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568); diff --git a/src/Tests/Tests/Shared/TestDouble3.gen.cs b/src/Tests/Tests/Shared/TestDouble3.gen.cs index 2bd08a5d..59b1478b 100644 --- a/src/Tests/Tests/Shared/TestDouble3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_zero() { TestUtils.AreEqual(0.0, double3.zero.x); @@ -23,7 +23,7 @@ public static void double3_zero() TestUtils.AreEqual(0.0, double3.zero.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_constructor() { double3 a = new double3(1, 2, 3); @@ -32,7 +32,7 @@ public static void double3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_scalar_constructor() { double3 a = new double3(17.0); @@ -41,7 +41,7 @@ public static void double3_scalar_constructor() TestUtils.AreEqual(17.0, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_static_constructor() { double3 a = double3(1, 2, 3); @@ -50,7 +50,7 @@ public static void double3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_static_scalar_constructor() { double3 a = double3(17.0); @@ -59,7 +59,7 @@ public static void double3_static_scalar_constructor() TestUtils.AreEqual(17.0, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_equal_wide_wide() { double3 a0 = double3(492.15758275061728, -495.20632027797694, 227.45765195947968); @@ -83,7 +83,7 @@ public static void double3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_equal_wide_scalar() { double3 a0 = double3(-303.2300766926399, 451.52631327674089, -253.65587413201848); @@ -107,7 +107,7 @@ public static void double3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -131,7 +131,7 @@ public static void double3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_not_equal_wide_wide() { double3 a0 = double3(430.8425316432689, 104.69001798736394, 225.80243478799355); @@ -155,7 +155,7 @@ public static void double3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_not_equal_wide_scalar() { double3 a0 = double3(-16.914588697680529, 168.83411486858233, -462.71352145760949); @@ -179,7 +179,7 @@ public static void double3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -203,7 +203,7 @@ public static void double3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_less_wide_wide() { double3 a0 = double3(196.84256825076534, 336.40979997087732, 251.96372115424072); @@ -227,7 +227,7 @@ public static void double3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_less_wide_scalar() { double3 a0 = double3(-132.05731708000292, -192.46500477216438, -66.834607870706634); @@ -251,7 +251,7 @@ public static void double3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -275,7 +275,7 @@ public static void double3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_greater_wide_wide() { double3 a0 = double3(483.50140141113729, 310.81563415695712, 106.9661896726891); @@ -299,7 +299,7 @@ public static void double3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_greater_wide_scalar() { double3 a0 = double3(64.317918092160426, -397.70346445483318, 431.87690826499693); @@ -323,7 +323,7 @@ public static void double3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -347,7 +347,7 @@ public static void double3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_less_equal_wide_wide() { double3 a0 = double3(-438.52313753521219, 210.48942837980087, 4.8773329280677444); @@ -371,7 +371,7 @@ public static void double3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_less_equal_wide_scalar() { double3 a0 = double3(193.4958237118534, 168.91555197952107, -313.9930695565385); @@ -395,7 +395,7 @@ public static void double3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -419,7 +419,7 @@ public static void double3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_greater_equal_wide_wide() { double3 a0 = double3(-507.92858409692, 504.49748181947393, -385.43449205226938); @@ -443,7 +443,7 @@ public static void double3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_greater_equal_wide_scalar() { double3 a0 = double3(465.15218732559686, -424.8860745024337, -209.22109685150025); @@ -467,7 +467,7 @@ public static void double3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -491,7 +491,7 @@ public static void double3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_add_wide_wide() { double3 a0 = double3(506.12905263627374, -501.77980803967444, 420.08479638587903); @@ -515,7 +515,7 @@ public static void double3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_add_wide_scalar() { double3 a0 = double3(-194.51420387742769, 338.54838696985894, 246.97140252169754); @@ -539,7 +539,7 @@ public static void double3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -563,7 +563,7 @@ public static void double3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_sub_wide_wide() { double3 a0 = double3(160.4922617229131, 11.223957305412682, 359.20010607279846); @@ -587,7 +587,7 @@ public static void double3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_sub_wide_scalar() { double3 a0 = double3(207.38960108877609, 248.45773684627272, -384.82393211164697); @@ -611,7 +611,7 @@ public static void double3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -635,7 +635,7 @@ public static void double3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_mul_wide_wide() { double3 a0 = double3(-482.71381710596097, -407.29348559272171, 137.70058995937029); @@ -659,7 +659,7 @@ public static void double3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_mul_wide_scalar() { double3 a0 = double3(-96.318821236639678, -277.14229239017811, -239.93690191951436); @@ -683,7 +683,7 @@ public static void double3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -707,7 +707,7 @@ public static void double3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_div_wide_wide() { double3 a0 = double3(-353.13144390337703, -102.79985456485292, 51.319128298814917); @@ -731,7 +731,7 @@ public static void double3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_div_wide_scalar() { double3 a0 = double3(171.34242184988341, 0.10338377957384637, 57.888263967767443); @@ -755,7 +755,7 @@ public static void double3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -779,7 +779,7 @@ public static void double3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_mod_wide_wide() { double3 a0 = double3(-388.81249422059045, 181.68118842955732, -167.07872470052854); @@ -803,7 +803,7 @@ public static void double3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_mod_wide_scalar() { double3 a0 = double3(-244.49962889612635, -211.81931958525411, -145.92677576184587); @@ -827,7 +827,7 @@ public static void double3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -851,7 +851,7 @@ public static void double3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_plus() { double3 a0 = double3(-418.82956357432045, -405.79894823851015, -34.041791216489742); @@ -871,7 +871,7 @@ public static void double3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_neg() { double3 a0 = double3(148.46174890755753, -467.12267873581624, 132.04719954917539); @@ -891,7 +891,7 @@ public static void double3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_prefix_inc() { double3 a0 = double3(-139.84208137348389, -56.743654039103376, -381.955324589254); @@ -911,7 +911,7 @@ public static void double3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_postfix_inc() { double3 a0 = double3(-396.6697396695007, 511.20749378167443, 249.11127030528678); @@ -931,7 +931,7 @@ public static void double3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_prefix_dec() { double3 a0 = double3(123.12869626056806, 256.8437465433235, 156.33078844674435); @@ -951,7 +951,7 @@ public static void double3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_operator_postfix_dec() { double3 a0 = double3(379.68831723727669, 302.69287814884115, -176.07134040448409); @@ -971,7 +971,7 @@ public static void double3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_shuffle_result_1() { double3 a = double3(0, 1, 2); @@ -985,7 +985,7 @@ public static void double3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_shuffle_result_2() { double3 a = double3(0, 1, 2); @@ -1009,7 +1009,7 @@ public static void double3_shuffle_result_2() TestUtils.AreEqual(double2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_shuffle_result_3() { double3 a = double3(0, 1, 2); @@ -1033,7 +1033,7 @@ public static void double3_shuffle_result_3() TestUtils.AreEqual(double3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_shuffle_result_4() { double3 a = double3(0, 1, 2); diff --git a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs index bbfffa3a..0fd677a3 100644 --- a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_zero() { TestUtils.AreEqual(0.0, double3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void double3x2_zero() TestUtils.AreEqual(0.0, double3x2.zero.c1.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_equal_wide_wide() { double3x2 a0 = double3x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749); @@ -50,7 +50,7 @@ public static void double3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_equal_wide_scalar() { double3x2 a0 = double3x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315); @@ -74,7 +74,7 @@ public static void double3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -98,7 +98,7 @@ public static void double3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_not_equal_wide_wide() { double3x2 a0 = double3x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379); @@ -122,7 +122,7 @@ public static void double3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_not_equal_wide_scalar() { double3x2 a0 = double3x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959); @@ -146,7 +146,7 @@ public static void double3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -170,7 +170,7 @@ public static void double3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_less_wide_wide() { double3x2 a0 = double3x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774); @@ -194,7 +194,7 @@ public static void double3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_less_wide_scalar() { double3x2 a0 = double3x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879); @@ -218,7 +218,7 @@ public static void double3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -242,7 +242,7 @@ public static void double3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_greater_wide_wide() { double3x2 a0 = double3x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479); @@ -266,7 +266,7 @@ public static void double3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_greater_wide_scalar() { double3x2 a0 = double3x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809); @@ -290,7 +290,7 @@ public static void double3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -314,7 +314,7 @@ public static void double3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_less_equal_wide_wide() { double3x2 a0 = double3x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475); @@ -338,7 +338,7 @@ public static void double3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_less_equal_wide_scalar() { double3x2 a0 = double3x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136); @@ -362,7 +362,7 @@ public static void double3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -386,7 +386,7 @@ public static void double3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_greater_equal_wide_wide() { double3x2 a0 = double3x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193); @@ -410,7 +410,7 @@ public static void double3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_greater_equal_wide_scalar() { double3x2 a0 = double3x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976); @@ -434,7 +434,7 @@ public static void double3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -458,7 +458,7 @@ public static void double3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_add_wide_wide() { double3x2 a0 = double3x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056); @@ -482,7 +482,7 @@ public static void double3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_add_wide_scalar() { double3x2 a0 = double3x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166); @@ -506,7 +506,7 @@ public static void double3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -530,7 +530,7 @@ public static void double3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_sub_wide_wide() { double3x2 a0 = double3x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053); @@ -554,7 +554,7 @@ public static void double3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_sub_wide_scalar() { double3x2 a0 = double3x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896); @@ -578,7 +578,7 @@ public static void double3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -602,7 +602,7 @@ public static void double3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_mul_wide_wide() { double3x2 a0 = double3x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747); @@ -626,7 +626,7 @@ public static void double3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_mul_wide_scalar() { double3x2 a0 = double3x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229); @@ -650,7 +650,7 @@ public static void double3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -674,7 +674,7 @@ public static void double3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_div_wide_wide() { double3x2 a0 = double3x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758); @@ -698,7 +698,7 @@ public static void double3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_div_wide_scalar() { double3x2 a0 = double3x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509); @@ -722,7 +722,7 @@ public static void double3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -746,7 +746,7 @@ public static void double3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_mod_wide_wide() { double3x2 a0 = double3x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406); @@ -770,7 +770,7 @@ public static void double3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_mod_wide_scalar() { double3x2 a0 = double3x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221); @@ -794,7 +794,7 @@ public static void double3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -818,7 +818,7 @@ public static void double3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_plus() { double3x2 a0 = double3x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287); @@ -838,7 +838,7 @@ public static void double3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_neg() { double3x2 a0 = double3x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605); @@ -858,7 +858,7 @@ public static void double3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_prefix_inc() { double3x2 a0 = double3x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198); @@ -878,7 +878,7 @@ public static void double3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_postfix_inc() { double3x2 a0 = double3x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219); @@ -898,7 +898,7 @@ public static void double3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_prefix_dec() { double3x2 a0 = double3x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339); @@ -918,7 +918,7 @@ public static void double3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x2_operator_postfix_dec() { double3x2 a0 = double3x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231); diff --git a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs index aca1ba86..d066be3d 100644 --- a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_zero() { TestUtils.AreEqual(0.0, double3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void double3x3_zero() TestUtils.AreEqual(0.0, double3x3.zero.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_identity() { TestUtils.AreEqual(1.0, double3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void double3x3_identity() TestUtils.AreEqual(1.0, double3x3.identity.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_equal_wide_wide() { double3x3 a0 = double3x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655); @@ -67,7 +67,7 @@ public static void double3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_equal_wide_scalar() { double3x3 a0 = double3x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386); @@ -91,7 +91,7 @@ public static void double3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -115,7 +115,7 @@ public static void double3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_not_equal_wide_wide() { double3x3 a0 = double3x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975); @@ -139,7 +139,7 @@ public static void double3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_not_equal_wide_scalar() { double3x3 a0 = double3x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783); @@ -163,7 +163,7 @@ public static void double3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -187,7 +187,7 @@ public static void double3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_less_wide_wide() { double3x3 a0 = double3x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472); @@ -211,7 +211,7 @@ public static void double3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_less_wide_scalar() { double3x3 a0 = double3x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772); @@ -235,7 +235,7 @@ public static void double3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -259,7 +259,7 @@ public static void double3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_greater_wide_wide() { double3x3 a0 = double3x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417); @@ -283,7 +283,7 @@ public static void double3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_greater_wide_scalar() { double3x3 a0 = double3x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148); @@ -307,7 +307,7 @@ public static void double3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -331,7 +331,7 @@ public static void double3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_less_equal_wide_wide() { double3x3 a0 = double3x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323); @@ -355,7 +355,7 @@ public static void double3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_less_equal_wide_scalar() { double3x3 a0 = double3x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203); @@ -379,7 +379,7 @@ public static void double3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -403,7 +403,7 @@ public static void double3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_greater_equal_wide_wide() { double3x3 a0 = double3x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094); @@ -427,7 +427,7 @@ public static void double3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_greater_equal_wide_scalar() { double3x3 a0 = double3x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562); @@ -451,7 +451,7 @@ public static void double3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -475,7 +475,7 @@ public static void double3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_add_wide_wide() { double3x3 a0 = double3x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012); @@ -499,7 +499,7 @@ public static void double3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_add_wide_scalar() { double3x3 a0 = double3x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084); @@ -523,7 +523,7 @@ public static void double3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -547,7 +547,7 @@ public static void double3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_sub_wide_wide() { double3x3 a0 = double3x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693); @@ -571,7 +571,7 @@ public static void double3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_sub_wide_scalar() { double3x3 a0 = double3x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796); @@ -595,7 +595,7 @@ public static void double3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -619,7 +619,7 @@ public static void double3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_mul_wide_wide() { double3x3 a0 = double3x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114); @@ -643,7 +643,7 @@ public static void double3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_mul_wide_scalar() { double3x3 a0 = double3x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419); @@ -667,7 +667,7 @@ public static void double3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -691,7 +691,7 @@ public static void double3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_div_wide_wide() { double3x3 a0 = double3x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105); @@ -715,7 +715,7 @@ public static void double3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_div_wide_scalar() { double3x3 a0 = double3x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234); @@ -739,7 +739,7 @@ public static void double3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -763,7 +763,7 @@ public static void double3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_mod_wide_wide() { double3x3 a0 = double3x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616); @@ -787,7 +787,7 @@ public static void double3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_mod_wide_scalar() { double3x3 a0 = double3x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039); @@ -811,7 +811,7 @@ public static void double3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -835,7 +835,7 @@ public static void double3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_plus() { double3x3 a0 = double3x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803); @@ -855,7 +855,7 @@ public static void double3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_neg() { double3x3 a0 = double3x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887); @@ -875,7 +875,7 @@ public static void double3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_prefix_inc() { double3x3 a0 = double3x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068); @@ -895,7 +895,7 @@ public static void double3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_postfix_inc() { double3x3 a0 = double3x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894); @@ -915,7 +915,7 @@ public static void double3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_prefix_dec() { double3x3 a0 = double3x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851); @@ -935,7 +935,7 @@ public static void double3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x3_operator_postfix_dec() { double3x3 a0 = double3x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415); diff --git a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs index 48170ecf..03ea5969 100644 --- a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble3x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_zero() { TestUtils.AreEqual(0.0, double3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void double3x4_zero() TestUtils.AreEqual(0.0, double3x4.zero.c3.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_equal_wide_wide() { double3x4 a0 = double3x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078); @@ -56,7 +56,7 @@ public static void double3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_equal_wide_scalar() { double3x4 a0 = double3x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978); @@ -80,7 +80,7 @@ public static void double3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -104,7 +104,7 @@ public static void double3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_not_equal_wide_wide() { double3x4 a0 = double3x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394); @@ -128,7 +128,7 @@ public static void double3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_not_equal_wide_scalar() { double3x4 a0 = double3x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992); @@ -152,7 +152,7 @@ public static void double3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -176,7 +176,7 @@ public static void double3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_less_wide_wide() { double3x4 a0 = double3x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725); @@ -200,7 +200,7 @@ public static void double3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_less_wide_scalar() { double3x4 a0 = double3x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562); @@ -224,7 +224,7 @@ public static void double3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -248,7 +248,7 @@ public static void double3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_greater_wide_wide() { double3x4 a0 = double3x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906); @@ -272,7 +272,7 @@ public static void double3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_greater_wide_scalar() { double3x4 a0 = double3x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745); @@ -296,7 +296,7 @@ public static void double3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -320,7 +320,7 @@ public static void double3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_less_equal_wide_wide() { double3x4 a0 = double3x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363); @@ -344,7 +344,7 @@ public static void double3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_less_equal_wide_scalar() { double3x4 a0 = double3x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836); @@ -368,7 +368,7 @@ public static void double3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -392,7 +392,7 @@ public static void double3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_greater_equal_wide_wide() { double3x4 a0 = double3x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473); @@ -416,7 +416,7 @@ public static void double3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_greater_equal_wide_scalar() { double3x4 a0 = double3x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435); @@ -440,7 +440,7 @@ public static void double3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -464,7 +464,7 @@ public static void double3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_add_wide_wide() { double3x4 a0 = double3x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627); @@ -488,7 +488,7 @@ public static void double3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_add_wide_scalar() { double3x4 a0 = double3x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649); @@ -512,7 +512,7 @@ public static void double3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -536,7 +536,7 @@ public static void double3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_sub_wide_wide() { double3x4 a0 = double3x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149); @@ -560,7 +560,7 @@ public static void double3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_sub_wide_scalar() { double3x4 a0 = double3x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335); @@ -584,7 +584,7 @@ public static void double3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -608,7 +608,7 @@ public static void double3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_mul_wide_wide() { double3x4 a0 = double3x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408); @@ -632,7 +632,7 @@ public static void double3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_mul_wide_scalar() { double3x4 a0 = double3x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186); @@ -656,7 +656,7 @@ public static void double3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -680,7 +680,7 @@ public static void double3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_div_wide_wide() { double3x4 a0 = double3x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039); @@ -704,7 +704,7 @@ public static void double3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_div_wide_scalar() { double3x4 a0 = double3x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787); @@ -728,7 +728,7 @@ public static void double3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -752,7 +752,7 @@ public static void double3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_mod_wide_wide() { double3x4 a0 = double3x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538); @@ -776,7 +776,7 @@ public static void double3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_mod_wide_scalar() { double3x4 a0 = double3x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423); @@ -800,7 +800,7 @@ public static void double3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -824,7 +824,7 @@ public static void double3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_plus() { double3x4 a0 = double3x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724); @@ -844,7 +844,7 @@ public static void double3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_neg() { double3x4 a0 = double3x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852); @@ -864,7 +864,7 @@ public static void double3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_prefix_inc() { double3x4 a0 = double3x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212); @@ -884,7 +884,7 @@ public static void double3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_postfix_inc() { double3x4 a0 = double3x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185); @@ -904,7 +904,7 @@ public static void double3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_prefix_dec() { double3x4 a0 = double3x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956); @@ -924,7 +924,7 @@ public static void double3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3x4_operator_postfix_dec() { double3x4 a0 = double3x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677); diff --git a/src/Tests/Tests/Shared/TestDouble4.gen.cs b/src/Tests/Tests/Shared/TestDouble4.gen.cs index 6dec9e23..0344dae9 100644 --- a/src/Tests/Tests/Shared/TestDouble4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_zero() { TestUtils.AreEqual(0.0, double4.zero.x); @@ -24,7 +24,7 @@ public static void double4_zero() TestUtils.AreEqual(0.0, double4.zero.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_constructor() { double4 a = new double4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void double4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_scalar_constructor() { double4 a = new double4(17.0); @@ -44,7 +44,7 @@ public static void double4_scalar_constructor() TestUtils.AreEqual(17.0, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_static_constructor() { double4 a = double4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void double4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_static_scalar_constructor() { double4 a = double4(17.0); @@ -64,7 +64,7 @@ public static void double4_static_scalar_constructor() TestUtils.AreEqual(17.0, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_equal_wide_wide() { double4 a0 = double4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182); @@ -88,7 +88,7 @@ public static void double4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_equal_wide_scalar() { double4 a0 = double4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995); @@ -112,7 +112,7 @@ public static void double4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -136,7 +136,7 @@ public static void double4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_not_equal_wide_wide() { double4 a0 = double4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048); @@ -160,7 +160,7 @@ public static void double4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_not_equal_wide_scalar() { double4 a0 = double4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137); @@ -184,7 +184,7 @@ public static void double4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -208,7 +208,7 @@ public static void double4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_less_wide_wide() { double4 a0 = double4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963); @@ -232,7 +232,7 @@ public static void double4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_less_wide_scalar() { double4 a0 = double4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561); @@ -256,7 +256,7 @@ public static void double4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -280,7 +280,7 @@ public static void double4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_greater_wide_wide() { double4 a0 = double4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671); @@ -304,7 +304,7 @@ public static void double4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_greater_wide_scalar() { double4 a0 = double4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157); @@ -328,7 +328,7 @@ public static void double4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -352,7 +352,7 @@ public static void double4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_less_equal_wide_wide() { double4 a0 = double4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857); @@ -376,7 +376,7 @@ public static void double4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_less_equal_wide_scalar() { double4 a0 = double4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292); @@ -400,7 +400,7 @@ public static void double4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -424,7 +424,7 @@ public static void double4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_greater_equal_wide_wide() { double4 a0 = double4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784); @@ -448,7 +448,7 @@ public static void double4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_greater_equal_wide_scalar() { double4 a0 = double4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356); @@ -472,7 +472,7 @@ public static void double4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -496,7 +496,7 @@ public static void double4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_add_wide_wide() { double4 a0 = double4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274); @@ -520,7 +520,7 @@ public static void double4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_add_wide_scalar() { double4 a0 = double4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752); @@ -544,7 +544,7 @@ public static void double4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -568,7 +568,7 @@ public static void double4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_sub_wide_wide() { double4 a0 = double4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311); @@ -592,7 +592,7 @@ public static void double4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_sub_wide_scalar() { double4 a0 = double4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506); @@ -616,7 +616,7 @@ public static void double4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -640,7 +640,7 @@ public static void double4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_mul_wide_wide() { double4 a0 = double4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182); @@ -664,7 +664,7 @@ public static void double4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_mul_wide_scalar() { double4 a0 = double4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409); @@ -688,7 +688,7 @@ public static void double4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -712,7 +712,7 @@ public static void double4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_div_wide_wide() { double4 a0 = double4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176); @@ -736,7 +736,7 @@ public static void double4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_div_wide_scalar() { double4 a0 = double4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078); @@ -760,7 +760,7 @@ public static void double4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -784,7 +784,7 @@ public static void double4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_mod_wide_wide() { double4 a0 = double4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813); @@ -808,7 +808,7 @@ public static void double4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_mod_wide_scalar() { double4 a0 = double4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672); @@ -832,7 +832,7 @@ public static void double4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -856,7 +856,7 @@ public static void double4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_plus() { double4 a0 = double4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421); @@ -876,7 +876,7 @@ public static void double4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_neg() { double4 a0 = double4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463); @@ -896,7 +896,7 @@ public static void double4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_prefix_inc() { double4 a0 = double4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962); @@ -916,7 +916,7 @@ public static void double4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_postfix_inc() { double4 a0 = double4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153); @@ -936,7 +936,7 @@ public static void double4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_prefix_dec() { double4 a0 = double4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563); @@ -956,7 +956,7 @@ public static void double4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_operator_postfix_dec() { double4 a0 = double4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962); @@ -976,7 +976,7 @@ public static void double4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_shuffle_result_1() { double4 a = double4(0, 1, 2, 3); @@ -992,7 +992,7 @@ public static void double4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_shuffle_result_2() { double4 a = double4(0, 1, 2, 3); @@ -1016,7 +1016,7 @@ public static void double4_shuffle_result_2() TestUtils.AreEqual(double2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_shuffle_result_3() { double4 a = double4(0, 1, 2, 3); @@ -1040,7 +1040,7 @@ public static void double4_shuffle_result_3() TestUtils.AreEqual(double3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_shuffle_result_4() { double4 a = double4(0, 1, 2, 3); diff --git a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs index 112a10df..80b2e856 100644 --- a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_zero() { TestUtils.AreEqual(0.0, double4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void double4x2_zero() TestUtils.AreEqual(0.0, double4x2.zero.c1.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_equal_wide_wide() { double4x2 a0 = double4x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889); @@ -52,7 +52,7 @@ public static void double4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_equal_wide_scalar() { double4x2 a0 = double4x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405); @@ -76,7 +76,7 @@ public static void double4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -100,7 +100,7 @@ public static void double4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_not_equal_wide_wide() { double4x2 a0 = double4x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895); @@ -124,7 +124,7 @@ public static void double4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_not_equal_wide_scalar() { double4x2 a0 = double4x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842); @@ -148,7 +148,7 @@ public static void double4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -172,7 +172,7 @@ public static void double4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_less_wide_wide() { double4x2 a0 = double4x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259); @@ -196,7 +196,7 @@ public static void double4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_less_wide_scalar() { double4x2 a0 = double4x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061); @@ -220,7 +220,7 @@ public static void double4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -244,7 +244,7 @@ public static void double4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_greater_wide_wide() { double4x2 a0 = double4x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484); @@ -268,7 +268,7 @@ public static void double4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_greater_wide_scalar() { double4x2 a0 = double4x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972); @@ -292,7 +292,7 @@ public static void double4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -316,7 +316,7 @@ public static void double4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_less_equal_wide_wide() { double4x2 a0 = double4x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232); @@ -340,7 +340,7 @@ public static void double4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_less_equal_wide_scalar() { double4x2 a0 = double4x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582); @@ -364,7 +364,7 @@ public static void double4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -388,7 +388,7 @@ public static void double4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_greater_equal_wide_wide() { double4x2 a0 = double4x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265); @@ -412,7 +412,7 @@ public static void double4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_greater_equal_wide_scalar() { double4x2 a0 = double4x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838); @@ -436,7 +436,7 @@ public static void double4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -460,7 +460,7 @@ public static void double4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_add_wide_wide() { double4x2 a0 = double4x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656); @@ -484,7 +484,7 @@ public static void double4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_add_wide_scalar() { double4x2 a0 = double4x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454); @@ -508,7 +508,7 @@ public static void double4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -532,7 +532,7 @@ public static void double4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_sub_wide_wide() { double4x2 a0 = double4x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537); @@ -556,7 +556,7 @@ public static void double4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_sub_wide_scalar() { double4x2 a0 = double4x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965); @@ -580,7 +580,7 @@ public static void double4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -604,7 +604,7 @@ public static void double4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_mul_wide_wide() { double4x2 a0 = double4x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149); @@ -628,7 +628,7 @@ public static void double4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_mul_wide_scalar() { double4x2 a0 = double4x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334); @@ -652,7 +652,7 @@ public static void double4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -676,7 +676,7 @@ public static void double4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_div_wide_wide() { double4x2 a0 = double4x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537); @@ -700,7 +700,7 @@ public static void double4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_div_wide_scalar() { double4x2 a0 = double4x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539); @@ -724,7 +724,7 @@ public static void double4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -748,7 +748,7 @@ public static void double4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_mod_wide_wide() { double4x2 a0 = double4x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664); @@ -772,7 +772,7 @@ public static void double4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_mod_wide_scalar() { double4x2 a0 = double4x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243); @@ -796,7 +796,7 @@ public static void double4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -820,7 +820,7 @@ public static void double4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_plus() { double4x2 a0 = double4x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488); @@ -840,7 +840,7 @@ public static void double4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_neg() { double4x2 a0 = double4x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581); @@ -860,7 +860,7 @@ public static void double4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_prefix_inc() { double4x2 a0 = double4x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267); @@ -880,7 +880,7 @@ public static void double4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_postfix_inc() { double4x2 a0 = double4x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271); @@ -900,7 +900,7 @@ public static void double4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_prefix_dec() { double4x2 a0 = double4x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558); @@ -920,7 +920,7 @@ public static void double4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x2_operator_postfix_dec() { double4x2 a0 = double4x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568); diff --git a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs index 90982950..6debf3f6 100644 --- a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_zero() { TestUtils.AreEqual(0.0, double4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void double4x3_zero() TestUtils.AreEqual(0.0, double4x3.zero.c2.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_equal_wide_wide() { double4x3 a0 = double4x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078); @@ -56,7 +56,7 @@ public static void double4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_equal_wide_scalar() { double4x3 a0 = double4x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978); @@ -80,7 +80,7 @@ public static void double4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -104,7 +104,7 @@ public static void double4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_not_equal_wide_wide() { double4x3 a0 = double4x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394); @@ -128,7 +128,7 @@ public static void double4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_not_equal_wide_scalar() { double4x3 a0 = double4x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992); @@ -152,7 +152,7 @@ public static void double4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -176,7 +176,7 @@ public static void double4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_less_wide_wide() { double4x3 a0 = double4x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725); @@ -200,7 +200,7 @@ public static void double4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_less_wide_scalar() { double4x3 a0 = double4x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562); @@ -224,7 +224,7 @@ public static void double4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -248,7 +248,7 @@ public static void double4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_greater_wide_wide() { double4x3 a0 = double4x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906); @@ -272,7 +272,7 @@ public static void double4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_greater_wide_scalar() { double4x3 a0 = double4x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745); @@ -296,7 +296,7 @@ public static void double4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -320,7 +320,7 @@ public static void double4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_less_equal_wide_wide() { double4x3 a0 = double4x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363); @@ -344,7 +344,7 @@ public static void double4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_less_equal_wide_scalar() { double4x3 a0 = double4x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836); @@ -368,7 +368,7 @@ public static void double4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -392,7 +392,7 @@ public static void double4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_greater_equal_wide_wide() { double4x3 a0 = double4x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473); @@ -416,7 +416,7 @@ public static void double4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_greater_equal_wide_scalar() { double4x3 a0 = double4x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435); @@ -440,7 +440,7 @@ public static void double4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -464,7 +464,7 @@ public static void double4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_add_wide_wide() { double4x3 a0 = double4x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627); @@ -488,7 +488,7 @@ public static void double4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_add_wide_scalar() { double4x3 a0 = double4x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649); @@ -512,7 +512,7 @@ public static void double4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -536,7 +536,7 @@ public static void double4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_sub_wide_wide() { double4x3 a0 = double4x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149); @@ -560,7 +560,7 @@ public static void double4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_sub_wide_scalar() { double4x3 a0 = double4x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335); @@ -584,7 +584,7 @@ public static void double4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -608,7 +608,7 @@ public static void double4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_mul_wide_wide() { double4x3 a0 = double4x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408); @@ -632,7 +632,7 @@ public static void double4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_mul_wide_scalar() { double4x3 a0 = double4x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186); @@ -656,7 +656,7 @@ public static void double4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -680,7 +680,7 @@ public static void double4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_div_wide_wide() { double4x3 a0 = double4x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039); @@ -704,7 +704,7 @@ public static void double4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_div_wide_scalar() { double4x3 a0 = double4x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787); @@ -728,7 +728,7 @@ public static void double4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -752,7 +752,7 @@ public static void double4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_mod_wide_wide() { double4x3 a0 = double4x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538); @@ -776,7 +776,7 @@ public static void double4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_mod_wide_scalar() { double4x3 a0 = double4x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423); @@ -800,7 +800,7 @@ public static void double4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -824,7 +824,7 @@ public static void double4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_plus() { double4x3 a0 = double4x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724); @@ -844,7 +844,7 @@ public static void double4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_neg() { double4x3 a0 = double4x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852); @@ -864,7 +864,7 @@ public static void double4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_prefix_inc() { double4x3 a0 = double4x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212); @@ -884,7 +884,7 @@ public static void double4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_postfix_inc() { double4x3 a0 = double4x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185); @@ -904,7 +904,7 @@ public static void double4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_prefix_dec() { double4x3 a0 = double4x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956); @@ -924,7 +924,7 @@ public static void double4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x3_operator_postfix_dec() { double4x3 a0 = double4x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677); diff --git a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs index 8c982bb3..3fcaff74 100644 --- a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestDouble4x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_zero() { TestUtils.AreEqual(0.0, double4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void double4x4_zero() TestUtils.AreEqual(0.0, double4x4.zero.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_identity() { TestUtils.AreEqual(1.0, double4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void double4x4_identity() TestUtils.AreEqual(1.0, double4x4.identity.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_equal_wide_wide() { double4x4 a0 = double4x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078, 109.63436918595539, 462.69031283943468, -335.38147727371262, 357.23446934168896); @@ -81,7 +81,7 @@ public static void double4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_equal_wide_scalar() { double4x4 a0 = double4x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978, -172.03530629539642, 455.40001198993991, -11.338988547836891, 363.93823044557973); @@ -105,7 +105,7 @@ public static void double4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_equal_scalar_wide() { double a0 = (-253.39728534100453); @@ -129,7 +129,7 @@ public static void double4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_not_equal_wide_wide() { double4x4 a0 = double4x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394, 65.662074358045174, 102.78780250567377, 172.93008120960098, 26.621009123800832); @@ -153,7 +153,7 @@ public static void double4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_not_equal_wide_scalar() { double4x4 a0 = double4x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992, -269.80570877241234, 299.65422763473089, -71.750904831919286, -432.75573917513515); @@ -177,7 +177,7 @@ public static void double4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_not_equal_scalar_wide() { double a0 = (275.79582823244664); @@ -201,7 +201,7 @@ public static void double4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_less_wide_wide() { double4x4 a0 = double4x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725, -111.12994127680076, 70.005523475820951, 448.19828173527412, -419.98711200244122); @@ -225,7 +225,7 @@ public static void double4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_less_wide_scalar() { double4x4 a0 = double4x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562, 373.54965584983563, 398.52368301829495, 105.0301654827922, -58.010895994496934); @@ -249,7 +249,7 @@ public static void double4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_less_scalar_wide() { double a0 = (-423.117411095238); @@ -273,7 +273,7 @@ public static void double4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_greater_wide_wide() { double4x4 a0 = double4x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906, 455.85146662958505, 144.70691139283917, 63.931990891663304, -285.68304099034663); @@ -297,7 +297,7 @@ public static void double4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_greater_wide_scalar() { double4x4 a0 = double4x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745, 370.27919524269146, -413.70138116073861, -356.5923551789449, -353.03129522550444); @@ -321,7 +321,7 @@ public static void double4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_greater_scalar_wide() { double a0 = (-282.67049635698572); @@ -345,7 +345,7 @@ public static void double4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_less_equal_wide_wide() { double4x4 a0 = double4x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363, 149.736484835733, -418.8866781754823, -197.50252899783783, -88.2055118494693); @@ -369,7 +369,7 @@ public static void double4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_less_equal_wide_scalar() { double4x4 a0 = double4x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836, -264.93778264938749, 82.258299150624453, 11.246050124636895, 424.7040156911612); @@ -393,7 +393,7 @@ public static void double4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_less_equal_scalar_wide() { double a0 = (393.60626644343427); @@ -417,7 +417,7 @@ public static void double4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_greater_equal_wide_wide() { double4x4 a0 = double4x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473, -309.57021608463032, -136.02249127999994, 280.73629082401112, -96.9958942388165); @@ -441,7 +441,7 @@ public static void double4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_greater_equal_wide_scalar() { double4x4 a0 = double4x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435, -36.994287269652943, 494.82028865014217, -164.97393830352183, -466.12009046325466); @@ -465,7 +465,7 @@ public static void double4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_greater_equal_scalar_wide() { double a0 = (374.82703393270594); @@ -489,7 +489,7 @@ public static void double4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_add_wide_wide() { double4x4 a0 = double4x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627, 69.195687564646732, -177.95734485329939, 299.60415544156183, 340.7048587001417); @@ -513,7 +513,7 @@ public static void double4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_add_wide_scalar() { double4x4 a0 = double4x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649, -188.26501068298938, -213.52673087526426, -267.78430688929944, 189.25996669999324); @@ -537,7 +537,7 @@ public static void double4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_add_scalar_wide() { double a0 = (-340.35468284243473); @@ -561,7 +561,7 @@ public static void double4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_sub_wide_wide() { double4x4 a0 = double4x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149, 24.875419389864192, 366.61447136784648, -107.3741567634857, -219.0081404275299); @@ -585,7 +585,7 @@ public static void double4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_sub_wide_scalar() { double4x4 a0 = double4x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335, 349.39776460705218, 439.07729336203886, 490.2222661870635, 195.02405104181923); @@ -609,7 +609,7 @@ public static void double4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_sub_scalar_wide() { double a0 = (-86.008225719448262); @@ -633,7 +633,7 @@ public static void double4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_mul_wide_wide() { double4x4 a0 = double4x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408, -262.68257415605831, -379.26274674910246, -374.09058182970182, 481.44738720424812); @@ -657,7 +657,7 @@ public static void double4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_mul_wide_scalar() { double4x4 a0 = double4x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186, -207.35010275959507, -383.93960946795517, -31.425238862366086, 42.676120539510634); @@ -681,7 +681,7 @@ public static void double4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_mul_scalar_wide() { double a0 = (37.432166355397612); @@ -705,7 +705,7 @@ public static void double4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_div_wide_wide() { double4x4 a0 = double4x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039, -416.22613234828509, -450.01919362042992, -273.49744594911925, -286.90817011841955); @@ -729,7 +729,7 @@ public static void double4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_div_wide_scalar() { double4x4 a0 = double4x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787, -205.03382143985192, 481.73814247629514, 464.47907159499778, -293.46349753693841); @@ -753,7 +753,7 @@ public static void double4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_div_scalar_wide() { double a0 = (-264.44250095283729); @@ -777,7 +777,7 @@ public static void double4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_mod_wide_wide() { double4x4 a0 = double4x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538, -124.03371745163281, 259.27395761165485, -274.35845030208975, -140.03080398404541); @@ -801,7 +801,7 @@ public static void double4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_mod_wide_scalar() { double4x4 a0 = double4x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423, -355.84685985923136, 259.37800061860025, -330.87193957477433, -284.34358109363518); @@ -825,7 +825,7 @@ public static void double4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_mod_scalar_wide() { double a0 = (-66.945025236785909); @@ -849,7 +849,7 @@ public static void double4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_plus() { double4x4 a0 = double4x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724, -170.74650843941907, 439.55937572920664, -478.74939916969714, 116.40075665172219); @@ -869,7 +869,7 @@ public static void double4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_neg() { double4x4 a0 = double4x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852, 466.44152829909763, 171.90249474900895, -280.55831564616335, -78.85761622286293); @@ -889,7 +889,7 @@ public static void double4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_prefix_inc() { double4x4 a0 = double4x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212, 243.54693114177644, 46.19202735190845, -41.497298975241051, 299.18547000511808); @@ -909,7 +909,7 @@ public static void double4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_postfix_inc() { double4x4 a0 = double4x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185, 128.5304239394751, 73.155582223625629, -60.132380275117384, -446.22976490772783); @@ -929,7 +929,7 @@ public static void double4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_prefix_dec() { double4x4 a0 = double4x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956, -363.07547991493504, -22.028951416736902, 248.79012667797042, 168.0950144120003); @@ -949,7 +949,7 @@ public static void double4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4x4_operator_postfix_dec() { double4x4 a0 = double4x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677, -200.30429491787419, -445.0269393609031, 407.42034907239508, 327.67032519340069); diff --git a/src/Tests/Tests/Shared/TestFloat2.gen.cs b/src/Tests/Tests/Shared/TestFloat2.gen.cs index acacdb83..885cbf2c 100644 --- a/src/Tests/Tests/Shared/TestFloat2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_zero() { TestUtils.AreEqual(0.0f, float2.zero.x); TestUtils.AreEqual(0.0f, float2.zero.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_constructor() { float2 a = new float2(1, 2); @@ -30,7 +30,7 @@ public static void float2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_scalar_constructor() { float2 a = new float2(17.0f); @@ -38,7 +38,7 @@ public static void float2_scalar_constructor() TestUtils.AreEqual(17.0f, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_static_constructor() { float2 a = float2(1, 2); @@ -46,7 +46,7 @@ public static void float2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_static_scalar_constructor() { float2 a = float2(17.0f); @@ -54,7 +54,7 @@ public static void float2_static_scalar_constructor() TestUtils.AreEqual(17.0f, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_equal_wide_wide() { float2 a0 = float2(492.1576f, -495.206329f); @@ -78,7 +78,7 @@ public static void float2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_equal_wide_scalar() { float2 a0 = float2(-303.230072f, 451.5263f); @@ -102,7 +102,7 @@ public static void float2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -126,7 +126,7 @@ public static void float2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_not_equal_wide_wide() { float2 a0 = float2(430.842529f, 104.69f); @@ -150,7 +150,7 @@ public static void float2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_not_equal_wide_scalar() { float2 a0 = float2(-16.9145813f, 168.8341f); @@ -174,7 +174,7 @@ public static void float2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -198,7 +198,7 @@ public static void float2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_less_wide_wide() { float2 a0 = float2(196.84259f, 336.4098f); @@ -222,7 +222,7 @@ public static void float2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_less_wide_scalar() { float2 a0 = float2(-132.057312f, -192.465f); @@ -246,7 +246,7 @@ public static void float2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -270,7 +270,7 @@ public static void float2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_greater_wide_wide() { float2 a0 = float2(483.5014f, 310.8156f); @@ -294,7 +294,7 @@ public static void float2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_greater_wide_scalar() { float2 a0 = float2(64.31793f, -397.703461f); @@ -318,7 +318,7 @@ public static void float2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -342,7 +342,7 @@ public static void float2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_less_equal_wide_wide() { float2 a0 = float2(-438.523132f, 210.489441f); @@ -366,7 +366,7 @@ public static void float2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_less_equal_wide_scalar() { float2 a0 = float2(193.49585f, 168.915527f); @@ -390,7 +390,7 @@ public static void float2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -414,7 +414,7 @@ public static void float2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_greater_equal_wide_wide() { float2 a0 = float2(-507.9286f, 504.4975f); @@ -438,7 +438,7 @@ public static void float2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_greater_equal_wide_scalar() { float2 a0 = float2(465.152161f, -424.886078f); @@ -462,7 +462,7 @@ public static void float2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -486,7 +486,7 @@ public static void float2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_add_wide_wide() { float2 a0 = float2(506.129028f, -501.779816f); @@ -510,7 +510,7 @@ public static void float2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_add_wide_scalar() { float2 a0 = float2(-194.514191f, 338.5484f); @@ -534,7 +534,7 @@ public static void float2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -558,7 +558,7 @@ public static void float2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_sub_wide_wide() { float2 a0 = float2(160.492249f, 11.223938f); @@ -582,7 +582,7 @@ public static void float2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_sub_wide_scalar() { float2 a0 = float2(207.389587f, 248.457764f); @@ -606,7 +606,7 @@ public static void float2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -630,7 +630,7 @@ public static void float2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_mul_wide_wide() { float2 a0 = float2(-482.7138f, -407.2935f); @@ -654,7 +654,7 @@ public static void float2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_mul_wide_scalar() { float2 a0 = float2(-96.31882f, -277.142273f); @@ -678,7 +678,7 @@ public static void float2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -702,7 +702,7 @@ public static void float2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_div_wide_wide() { float2 a0 = float2(-353.131439f, -102.799866f); @@ -726,7 +726,7 @@ public static void float2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_div_wide_scalar() { float2 a0 = float2(171.3424f, 0.103393555f); @@ -750,7 +750,7 @@ public static void float2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -774,7 +774,7 @@ public static void float2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_mod_wide_wide() { float2 a0 = float2(-388.8125f, 181.681213f); @@ -798,7 +798,7 @@ public static void float2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_mod_wide_scalar() { float2 a0 = float2(-244.499634f, -211.8193f); @@ -822,7 +822,7 @@ public static void float2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -846,7 +846,7 @@ public static void float2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_plus() { float2 a0 = float2(-418.829559f, -405.79895f); @@ -866,7 +866,7 @@ public static void float2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_neg() { float2 a0 = float2(148.461731f, -467.122681f); @@ -886,7 +886,7 @@ public static void float2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_prefix_inc() { float2 a0 = float2(-139.842072f, -56.7436523f); @@ -906,7 +906,7 @@ public static void float2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_postfix_inc() { float2 a0 = float2(-396.669739f, 511.20752f); @@ -926,7 +926,7 @@ public static void float2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_prefix_dec() { float2 a0 = float2(123.128723f, 256.84375f); @@ -946,7 +946,7 @@ public static void float2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_operator_postfix_dec() { float2 a0 = float2(379.6883f, 302.692871f); @@ -966,7 +966,7 @@ public static void float2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_shuffle_result_1() { float2 a = float2(0, 1); @@ -978,7 +978,7 @@ public static void float2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_shuffle_result_2() { float2 a = float2(0, 1); @@ -1002,7 +1002,7 @@ public static void float2_shuffle_result_2() TestUtils.AreEqual(float2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_shuffle_result_3() { float2 a = float2(0, 1); @@ -1026,7 +1026,7 @@ public static void float2_shuffle_result_3() TestUtils.AreEqual(float3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_shuffle_result_4() { float2 a = float2(0, 1); diff --git a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs index c5594164..b56dd1c0 100644 --- a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_zero() { TestUtils.AreEqual(0.0f, float2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void float2x2_zero() TestUtils.AreEqual(0.0f, float2x2.zero.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_identity() { TestUtils.AreEqual(1.0f, float2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void float2x2_identity() TestUtils.AreEqual(1.0f, float2x2.identity.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_equal_wide_wide() { float2x2 a0 = float2x2(492.1576f, -495.206329f, 227.457642f, -147.374054f); @@ -57,7 +57,7 @@ public static void float2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_equal_wide_scalar() { float2x2 a0 = float2x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f); @@ -81,7 +81,7 @@ public static void float2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -105,7 +105,7 @@ public static void float2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_not_equal_wide_wide() { float2x2 a0 = float2x2(430.842529f, 104.69f, 225.802429f, -310.5702f); @@ -129,7 +129,7 @@ public static void float2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_not_equal_wide_scalar() { float2x2 a0 = float2x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f); @@ -153,7 +153,7 @@ public static void float2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -177,7 +177,7 @@ public static void float2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_less_wide_wide() { float2x2 a0 = float2x2(196.84259f, 336.4098f, 251.963745f, 257.655945f); @@ -201,7 +201,7 @@ public static void float2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_less_wide_scalar() { float2x2 a0 = float2x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f); @@ -225,7 +225,7 @@ public static void float2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -249,7 +249,7 @@ public static void float2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_greater_wide_wide() { float2x2 a0 = float2x2(483.5014f, 310.8156f, 106.966187f, 295.7353f); @@ -273,7 +273,7 @@ public static void float2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_greater_wide_scalar() { float2x2 a0 = float2x2(64.31793f, -397.703461f, 431.8769f, 85.703f); @@ -297,7 +297,7 @@ public static void float2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -321,7 +321,7 @@ public static void float2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_less_equal_wide_wide() { float2x2 a0 = float2x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f); @@ -345,7 +345,7 @@ public static void float2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_less_equal_wide_scalar() { float2x2 a0 = float2x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f); @@ -369,7 +369,7 @@ public static void float2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -393,7 +393,7 @@ public static void float2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_greater_equal_wide_wide() { float2x2 a0 = float2x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f); @@ -417,7 +417,7 @@ public static void float2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_greater_equal_wide_scalar() { float2x2 a0 = float2x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f); @@ -441,7 +441,7 @@ public static void float2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -465,7 +465,7 @@ public static void float2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_add_wide_wide() { float2x2 a0 = float2x2(506.129028f, -501.779816f, 420.084778f, -186.032074f); @@ -489,7 +489,7 @@ public static void float2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_add_wide_scalar() { float2x2 a0 = float2x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f); @@ -513,7 +513,7 @@ public static void float2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -537,7 +537,7 @@ public static void float2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_sub_wide_wide() { float2x2 a0 = float2x2(160.492249f, 11.223938f, 359.200134f, -498.2283f); @@ -561,7 +561,7 @@ public static void float2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_sub_wide_scalar() { float2x2 a0 = float2x2(207.389587f, 248.457764f, -384.8239f, -205.344757f); @@ -585,7 +585,7 @@ public static void float2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -609,7 +609,7 @@ public static void float2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_mul_wide_wide() { float2x2 a0 = float2x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f); @@ -633,7 +633,7 @@ public static void float2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_mul_wide_scalar() { float2x2 a0 = float2x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f); @@ -657,7 +657,7 @@ public static void float2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -681,7 +681,7 @@ public static void float2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_div_wide_wide() { float2x2 a0 = float2x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f); @@ -705,7 +705,7 @@ public static void float2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_div_wide_scalar() { float2x2 a0 = float2x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f); @@ -729,7 +729,7 @@ public static void float2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -753,7 +753,7 @@ public static void float2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_mod_wide_wide() { float2x2 a0 = float2x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f); @@ -777,7 +777,7 @@ public static void float2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_mod_wide_scalar() { float2x2 a0 = float2x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f); @@ -801,7 +801,7 @@ public static void float2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -825,7 +825,7 @@ public static void float2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_plus() { float2x2 a0 = float2x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f); @@ -845,7 +845,7 @@ public static void float2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_neg() { float2x2 a0 = float2x2(148.461731f, -467.122681f, 132.04718f, 183.522644f); @@ -865,7 +865,7 @@ public static void float2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_prefix_inc() { float2x2 a0 = float2x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f); @@ -885,7 +885,7 @@ public static void float2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_postfix_inc() { float2x2 a0 = float2x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f); @@ -905,7 +905,7 @@ public static void float2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_prefix_dec() { float2x2 a0 = float2x2(123.128723f, 256.84375f, 156.330811f, 461.737427f); @@ -925,7 +925,7 @@ public static void float2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_operator_postfix_dec() { float2x2 a0 = float2x2(379.6883f, 302.692871f, -176.07135f, -291.2527f); diff --git a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs index e619dc0d..ee756468 100644 --- a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_zero() { TestUtils.AreEqual(0.0f, float2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void float2x3_zero() TestUtils.AreEqual(0.0f, float2x3.zero.c2.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_equal_wide_wide() { float2x3 a0 = float2x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f); @@ -50,7 +50,7 @@ public static void float2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_equal_wide_scalar() { float2x3 a0 = float2x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f); @@ -74,7 +74,7 @@ public static void float2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -98,7 +98,7 @@ public static void float2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_not_equal_wide_wide() { float2x3 a0 = float2x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f); @@ -122,7 +122,7 @@ public static void float2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_not_equal_wide_scalar() { float2x3 a0 = float2x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f); @@ -146,7 +146,7 @@ public static void float2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -170,7 +170,7 @@ public static void float2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_less_wide_wide() { float2x3 a0 = float2x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f); @@ -194,7 +194,7 @@ public static void float2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_less_wide_scalar() { float2x3 a0 = float2x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f); @@ -218,7 +218,7 @@ public static void float2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -242,7 +242,7 @@ public static void float2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_greater_wide_wide() { float2x3 a0 = float2x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f); @@ -266,7 +266,7 @@ public static void float2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_greater_wide_scalar() { float2x3 a0 = float2x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f); @@ -290,7 +290,7 @@ public static void float2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -314,7 +314,7 @@ public static void float2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_less_equal_wide_wide() { float2x3 a0 = float2x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f); @@ -338,7 +338,7 @@ public static void float2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_less_equal_wide_scalar() { float2x3 a0 = float2x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f); @@ -362,7 +362,7 @@ public static void float2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -386,7 +386,7 @@ public static void float2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_greater_equal_wide_wide() { float2x3 a0 = float2x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f); @@ -410,7 +410,7 @@ public static void float2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_greater_equal_wide_scalar() { float2x3 a0 = float2x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f); @@ -434,7 +434,7 @@ public static void float2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -458,7 +458,7 @@ public static void float2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_add_wide_wide() { float2x3 a0 = float2x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f); @@ -482,7 +482,7 @@ public static void float2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_add_wide_scalar() { float2x3 a0 = float2x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f); @@ -506,7 +506,7 @@ public static void float2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -530,7 +530,7 @@ public static void float2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_sub_wide_wide() { float2x3 a0 = float2x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f); @@ -554,7 +554,7 @@ public static void float2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_sub_wide_scalar() { float2x3 a0 = float2x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f); @@ -578,7 +578,7 @@ public static void float2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -602,7 +602,7 @@ public static void float2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_mul_wide_wide() { float2x3 a0 = float2x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f); @@ -626,7 +626,7 @@ public static void float2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_mul_wide_scalar() { float2x3 a0 = float2x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f); @@ -650,7 +650,7 @@ public static void float2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -674,7 +674,7 @@ public static void float2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_div_wide_wide() { float2x3 a0 = float2x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f); @@ -698,7 +698,7 @@ public static void float2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_div_wide_scalar() { float2x3 a0 = float2x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f); @@ -722,7 +722,7 @@ public static void float2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -746,7 +746,7 @@ public static void float2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_mod_wide_wide() { float2x3 a0 = float2x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f); @@ -770,7 +770,7 @@ public static void float2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_mod_wide_scalar() { float2x3 a0 = float2x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f); @@ -794,7 +794,7 @@ public static void float2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -818,7 +818,7 @@ public static void float2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_plus() { float2x3 a0 = float2x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f); @@ -838,7 +838,7 @@ public static void float2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_neg() { float2x3 a0 = float2x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f); @@ -858,7 +858,7 @@ public static void float2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_prefix_inc() { float2x3 a0 = float2x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f); @@ -878,7 +878,7 @@ public static void float2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_postfix_inc() { float2x3 a0 = float2x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f); @@ -898,7 +898,7 @@ public static void float2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_prefix_dec() { float2x3 a0 = float2x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f); @@ -918,7 +918,7 @@ public static void float2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x3_operator_postfix_dec() { float2x3 a0 = float2x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f); diff --git a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs index 19447921..769a761e 100644 --- a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat2x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_zero() { TestUtils.AreEqual(0.0f, float2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void float2x4_zero() TestUtils.AreEqual(0.0f, float2x4.zero.c3.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_equal_wide_wide() { float2x4 a0 = float2x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f); @@ -52,7 +52,7 @@ public static void float2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_equal_wide_scalar() { float2x4 a0 = float2x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f); @@ -76,7 +76,7 @@ public static void float2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -100,7 +100,7 @@ public static void float2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_not_equal_wide_wide() { float2x4 a0 = float2x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f); @@ -124,7 +124,7 @@ public static void float2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_not_equal_wide_scalar() { float2x4 a0 = float2x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f); @@ -148,7 +148,7 @@ public static void float2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -172,7 +172,7 @@ public static void float2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_less_wide_wide() { float2x4 a0 = float2x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f); @@ -196,7 +196,7 @@ public static void float2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_less_wide_scalar() { float2x4 a0 = float2x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f); @@ -220,7 +220,7 @@ public static void float2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -244,7 +244,7 @@ public static void float2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_greater_wide_wide() { float2x4 a0 = float2x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f); @@ -268,7 +268,7 @@ public static void float2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_greater_wide_scalar() { float2x4 a0 = float2x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f); @@ -292,7 +292,7 @@ public static void float2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -316,7 +316,7 @@ public static void float2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_less_equal_wide_wide() { float2x4 a0 = float2x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f); @@ -340,7 +340,7 @@ public static void float2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_less_equal_wide_scalar() { float2x4 a0 = float2x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f); @@ -364,7 +364,7 @@ public static void float2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -388,7 +388,7 @@ public static void float2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_greater_equal_wide_wide() { float2x4 a0 = float2x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f); @@ -412,7 +412,7 @@ public static void float2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_greater_equal_wide_scalar() { float2x4 a0 = float2x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f); @@ -436,7 +436,7 @@ public static void float2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -460,7 +460,7 @@ public static void float2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_add_wide_wide() { float2x4 a0 = float2x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f); @@ -484,7 +484,7 @@ public static void float2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_add_wide_scalar() { float2x4 a0 = float2x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f); @@ -508,7 +508,7 @@ public static void float2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -532,7 +532,7 @@ public static void float2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_sub_wide_wide() { float2x4 a0 = float2x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f); @@ -556,7 +556,7 @@ public static void float2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_sub_wide_scalar() { float2x4 a0 = float2x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f); @@ -580,7 +580,7 @@ public static void float2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -604,7 +604,7 @@ public static void float2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_mul_wide_wide() { float2x4 a0 = float2x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f); @@ -628,7 +628,7 @@ public static void float2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_mul_wide_scalar() { float2x4 a0 = float2x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f); @@ -652,7 +652,7 @@ public static void float2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -676,7 +676,7 @@ public static void float2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_div_wide_wide() { float2x4 a0 = float2x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f); @@ -700,7 +700,7 @@ public static void float2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_div_wide_scalar() { float2x4 a0 = float2x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f); @@ -724,7 +724,7 @@ public static void float2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -748,7 +748,7 @@ public static void float2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_mod_wide_wide() { float2x4 a0 = float2x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f); @@ -772,7 +772,7 @@ public static void float2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_mod_wide_scalar() { float2x4 a0 = float2x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f); @@ -796,7 +796,7 @@ public static void float2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -820,7 +820,7 @@ public static void float2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_plus() { float2x4 a0 = float2x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f); @@ -840,7 +840,7 @@ public static void float2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_neg() { float2x4 a0 = float2x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f); @@ -860,7 +860,7 @@ public static void float2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_prefix_inc() { float2x4 a0 = float2x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f); @@ -880,7 +880,7 @@ public static void float2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_postfix_inc() { float2x4 a0 = float2x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f); @@ -900,7 +900,7 @@ public static void float2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_prefix_dec() { float2x4 a0 = float2x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f); @@ -920,7 +920,7 @@ public static void float2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x4_operator_postfix_dec() { float2x4 a0 = float2x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f); diff --git a/src/Tests/Tests/Shared/TestFloat3.gen.cs b/src/Tests/Tests/Shared/TestFloat3.gen.cs index 40a4db85..29bbf5a0 100644 --- a/src/Tests/Tests/Shared/TestFloat3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_zero() { TestUtils.AreEqual(0.0f, float3.zero.x); @@ -23,7 +23,7 @@ public static void float3_zero() TestUtils.AreEqual(0.0f, float3.zero.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_constructor() { float3 a = new float3(1, 2, 3); @@ -32,7 +32,7 @@ public static void float3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_scalar_constructor() { float3 a = new float3(17.0f); @@ -41,7 +41,7 @@ public static void float3_scalar_constructor() TestUtils.AreEqual(17.0f, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_static_constructor() { float3 a = float3(1, 2, 3); @@ -50,7 +50,7 @@ public static void float3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_static_scalar_constructor() { float3 a = float3(17.0f); @@ -59,7 +59,7 @@ public static void float3_static_scalar_constructor() TestUtils.AreEqual(17.0f, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_equal_wide_wide() { float3 a0 = float3(492.1576f, -495.206329f, 227.457642f); @@ -83,7 +83,7 @@ public static void float3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_equal_wide_scalar() { float3 a0 = float3(-303.230072f, 451.5263f, -253.655884f); @@ -107,7 +107,7 @@ public static void float3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -131,7 +131,7 @@ public static void float3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_not_equal_wide_wide() { float3 a0 = float3(430.842529f, 104.69f, 225.802429f); @@ -155,7 +155,7 @@ public static void float3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_not_equal_wide_scalar() { float3 a0 = float3(-16.9145813f, 168.8341f, -462.713531f); @@ -179,7 +179,7 @@ public static void float3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -203,7 +203,7 @@ public static void float3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_less_wide_wide() { float3 a0 = float3(196.84259f, 336.4098f, 251.963745f); @@ -227,7 +227,7 @@ public static void float3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_less_wide_scalar() { float3 a0 = float3(-132.057312f, -192.465f, -66.8345947f); @@ -251,7 +251,7 @@ public static void float3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -275,7 +275,7 @@ public static void float3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_greater_wide_wide() { float3 a0 = float3(483.5014f, 310.8156f, 106.966187f); @@ -299,7 +299,7 @@ public static void float3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_greater_wide_scalar() { float3 a0 = float3(64.31793f, -397.703461f, 431.8769f); @@ -323,7 +323,7 @@ public static void float3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -347,7 +347,7 @@ public static void float3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_less_equal_wide_wide() { float3 a0 = float3(-438.523132f, 210.489441f, 4.87731934f); @@ -371,7 +371,7 @@ public static void float3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_less_equal_wide_scalar() { float3 a0 = float3(193.49585f, 168.915527f, -313.993073f); @@ -395,7 +395,7 @@ public static void float3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -419,7 +419,7 @@ public static void float3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_greater_equal_wide_wide() { float3 a0 = float3(-507.9286f, 504.4975f, -385.4345f); @@ -443,7 +443,7 @@ public static void float3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_greater_equal_wide_scalar() { float3 a0 = float3(465.152161f, -424.886078f, -209.2211f); @@ -467,7 +467,7 @@ public static void float3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -491,7 +491,7 @@ public static void float3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_add_wide_wide() { float3 a0 = float3(506.129028f, -501.779816f, 420.084778f); @@ -515,7 +515,7 @@ public static void float3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_add_wide_scalar() { float3 a0 = float3(-194.514191f, 338.5484f, 246.971375f); @@ -539,7 +539,7 @@ public static void float3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -563,7 +563,7 @@ public static void float3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_sub_wide_wide() { float3 a0 = float3(160.492249f, 11.223938f, 359.200134f); @@ -587,7 +587,7 @@ public static void float3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_sub_wide_scalar() { float3 a0 = float3(207.389587f, 248.457764f, -384.8239f); @@ -611,7 +611,7 @@ public static void float3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -635,7 +635,7 @@ public static void float3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_mul_wide_wide() { float3 a0 = float3(-482.7138f, -407.2935f, 137.700562f); @@ -659,7 +659,7 @@ public static void float3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_mul_wide_scalar() { float3 a0 = float3(-96.31882f, -277.142273f, -239.93689f); @@ -683,7 +683,7 @@ public static void float3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -707,7 +707,7 @@ public static void float3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_div_wide_wide() { float3 a0 = float3(-353.131439f, -102.799866f, 51.3191528f); @@ -731,7 +731,7 @@ public static void float3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_div_wide_scalar() { float3 a0 = float3(171.3424f, 0.103393555f, 57.8882446f); @@ -755,7 +755,7 @@ public static void float3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -779,7 +779,7 @@ public static void float3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_mod_wide_wide() { float3 a0 = float3(-388.8125f, 181.681213f, -167.078735f); @@ -803,7 +803,7 @@ public static void float3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_mod_wide_scalar() { float3 a0 = float3(-244.499634f, -211.8193f, -145.926788f); @@ -827,7 +827,7 @@ public static void float3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -851,7 +851,7 @@ public static void float3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_plus() { float3 a0 = float3(-418.829559f, -405.79895f, -34.04178f); @@ -871,7 +871,7 @@ public static void float3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_neg() { float3 a0 = float3(148.461731f, -467.122681f, 132.04718f); @@ -891,7 +891,7 @@ public static void float3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_prefix_inc() { float3 a0 = float3(-139.842072f, -56.7436523f, -381.955322f); @@ -911,7 +911,7 @@ public static void float3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_postfix_inc() { float3 a0 = float3(-396.669739f, 511.20752f, 249.111267f); @@ -931,7 +931,7 @@ public static void float3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_prefix_dec() { float3 a0 = float3(123.128723f, 256.84375f, 156.330811f); @@ -951,7 +951,7 @@ public static void float3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_operator_postfix_dec() { float3 a0 = float3(379.6883f, 302.692871f, -176.07135f); @@ -971,7 +971,7 @@ public static void float3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_shuffle_result_1() { float3 a = float3(0, 1, 2); @@ -985,7 +985,7 @@ public static void float3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_shuffle_result_2() { float3 a = float3(0, 1, 2); @@ -1009,7 +1009,7 @@ public static void float3_shuffle_result_2() TestUtils.AreEqual(float2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_shuffle_result_3() { float3 a = float3(0, 1, 2); @@ -1033,7 +1033,7 @@ public static void float3_shuffle_result_3() TestUtils.AreEqual(float3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_shuffle_result_4() { float3 a = float3(0, 1, 2); diff --git a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs index dabe0e58..a9fcca5b 100644 --- a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_zero() { TestUtils.AreEqual(0.0f, float3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void float3x2_zero() TestUtils.AreEqual(0.0f, float3x2.zero.c1.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_equal_wide_wide() { float3x2 a0 = float3x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f); @@ -50,7 +50,7 @@ public static void float3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_equal_wide_scalar() { float3x2 a0 = float3x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f); @@ -74,7 +74,7 @@ public static void float3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -98,7 +98,7 @@ public static void float3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_not_equal_wide_wide() { float3x2 a0 = float3x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f); @@ -122,7 +122,7 @@ public static void float3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_not_equal_wide_scalar() { float3x2 a0 = float3x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f); @@ -146,7 +146,7 @@ public static void float3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -170,7 +170,7 @@ public static void float3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_less_wide_wide() { float3x2 a0 = float3x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f); @@ -194,7 +194,7 @@ public static void float3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_less_wide_scalar() { float3x2 a0 = float3x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f); @@ -218,7 +218,7 @@ public static void float3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -242,7 +242,7 @@ public static void float3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_greater_wide_wide() { float3x2 a0 = float3x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f); @@ -266,7 +266,7 @@ public static void float3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_greater_wide_scalar() { float3x2 a0 = float3x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f); @@ -290,7 +290,7 @@ public static void float3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -314,7 +314,7 @@ public static void float3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_less_equal_wide_wide() { float3x2 a0 = float3x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f); @@ -338,7 +338,7 @@ public static void float3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_less_equal_wide_scalar() { float3x2 a0 = float3x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f); @@ -362,7 +362,7 @@ public static void float3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -386,7 +386,7 @@ public static void float3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_greater_equal_wide_wide() { float3x2 a0 = float3x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f); @@ -410,7 +410,7 @@ public static void float3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_greater_equal_wide_scalar() { float3x2 a0 = float3x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f); @@ -434,7 +434,7 @@ public static void float3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -458,7 +458,7 @@ public static void float3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_add_wide_wide() { float3x2 a0 = float3x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f); @@ -482,7 +482,7 @@ public static void float3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_add_wide_scalar() { float3x2 a0 = float3x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f); @@ -506,7 +506,7 @@ public static void float3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -530,7 +530,7 @@ public static void float3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_sub_wide_wide() { float3x2 a0 = float3x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f); @@ -554,7 +554,7 @@ public static void float3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_sub_wide_scalar() { float3x2 a0 = float3x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f); @@ -578,7 +578,7 @@ public static void float3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -602,7 +602,7 @@ public static void float3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_mul_wide_wide() { float3x2 a0 = float3x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f); @@ -626,7 +626,7 @@ public static void float3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_mul_wide_scalar() { float3x2 a0 = float3x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f); @@ -650,7 +650,7 @@ public static void float3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -674,7 +674,7 @@ public static void float3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_div_wide_wide() { float3x2 a0 = float3x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f); @@ -698,7 +698,7 @@ public static void float3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_div_wide_scalar() { float3x2 a0 = float3x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f); @@ -722,7 +722,7 @@ public static void float3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -746,7 +746,7 @@ public static void float3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_mod_wide_wide() { float3x2 a0 = float3x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f); @@ -770,7 +770,7 @@ public static void float3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_mod_wide_scalar() { float3x2 a0 = float3x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f); @@ -794,7 +794,7 @@ public static void float3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -818,7 +818,7 @@ public static void float3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_plus() { float3x2 a0 = float3x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f); @@ -838,7 +838,7 @@ public static void float3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_neg() { float3x2 a0 = float3x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f); @@ -858,7 +858,7 @@ public static void float3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_prefix_inc() { float3x2 a0 = float3x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f); @@ -878,7 +878,7 @@ public static void float3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_postfix_inc() { float3x2 a0 = float3x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f); @@ -898,7 +898,7 @@ public static void float3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_prefix_dec() { float3x2 a0 = float3x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f); @@ -918,7 +918,7 @@ public static void float3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x2_operator_postfix_dec() { float3x2 a0 = float3x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f); diff --git a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs index 6326f34f..7561ab09 100644 --- a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_zero() { TestUtils.AreEqual(0.0f, float3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void float3x3_zero() TestUtils.AreEqual(0.0f, float3x3.zero.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_identity() { TestUtils.AreEqual(1.0f, float3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void float3x3_identity() TestUtils.AreEqual(1.0f, float3x3.identity.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_equal_wide_wide() { float3x3 a0 = float3x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f); @@ -67,7 +67,7 @@ public static void float3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_equal_wide_scalar() { float3x3 a0 = float3x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f); @@ -91,7 +91,7 @@ public static void float3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -115,7 +115,7 @@ public static void float3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_not_equal_wide_wide() { float3x3 a0 = float3x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f); @@ -139,7 +139,7 @@ public static void float3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_not_equal_wide_scalar() { float3x3 a0 = float3x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f); @@ -163,7 +163,7 @@ public static void float3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -187,7 +187,7 @@ public static void float3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_less_wide_wide() { float3x3 a0 = float3x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f); @@ -211,7 +211,7 @@ public static void float3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_less_wide_scalar() { float3x3 a0 = float3x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f); @@ -235,7 +235,7 @@ public static void float3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -259,7 +259,7 @@ public static void float3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_greater_wide_wide() { float3x3 a0 = float3x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f); @@ -283,7 +283,7 @@ public static void float3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_greater_wide_scalar() { float3x3 a0 = float3x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f); @@ -307,7 +307,7 @@ public static void float3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -331,7 +331,7 @@ public static void float3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_less_equal_wide_wide() { float3x3 a0 = float3x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f); @@ -355,7 +355,7 @@ public static void float3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_less_equal_wide_scalar() { float3x3 a0 = float3x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f); @@ -379,7 +379,7 @@ public static void float3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -403,7 +403,7 @@ public static void float3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_greater_equal_wide_wide() { float3x3 a0 = float3x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f); @@ -427,7 +427,7 @@ public static void float3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_greater_equal_wide_scalar() { float3x3 a0 = float3x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f); @@ -451,7 +451,7 @@ public static void float3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -475,7 +475,7 @@ public static void float3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_add_wide_wide() { float3x3 a0 = float3x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f); @@ -499,7 +499,7 @@ public static void float3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_add_wide_scalar() { float3x3 a0 = float3x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f); @@ -523,7 +523,7 @@ public static void float3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -547,7 +547,7 @@ public static void float3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_sub_wide_wide() { float3x3 a0 = float3x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f); @@ -571,7 +571,7 @@ public static void float3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_sub_wide_scalar() { float3x3 a0 = float3x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f); @@ -595,7 +595,7 @@ public static void float3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -619,7 +619,7 @@ public static void float3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_mul_wide_wide() { float3x3 a0 = float3x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f); @@ -643,7 +643,7 @@ public static void float3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_mul_wide_scalar() { float3x3 a0 = float3x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f); @@ -667,7 +667,7 @@ public static void float3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -691,7 +691,7 @@ public static void float3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_div_wide_wide() { float3x3 a0 = float3x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f); @@ -715,7 +715,7 @@ public static void float3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_div_wide_scalar() { float3x3 a0 = float3x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f); @@ -739,7 +739,7 @@ public static void float3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -763,7 +763,7 @@ public static void float3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_mod_wide_wide() { float3x3 a0 = float3x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f); @@ -787,7 +787,7 @@ public static void float3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_mod_wide_scalar() { float3x3 a0 = float3x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f); @@ -811,7 +811,7 @@ public static void float3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -835,7 +835,7 @@ public static void float3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_plus() { float3x3 a0 = float3x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f); @@ -855,7 +855,7 @@ public static void float3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_neg() { float3x3 a0 = float3x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f); @@ -875,7 +875,7 @@ public static void float3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_prefix_inc() { float3x3 a0 = float3x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f); @@ -895,7 +895,7 @@ public static void float3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_postfix_inc() { float3x3 a0 = float3x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f); @@ -915,7 +915,7 @@ public static void float3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_prefix_dec() { float3x3 a0 = float3x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f); @@ -935,7 +935,7 @@ public static void float3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_operator_postfix_dec() { float3x3 a0 = float3x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f); diff --git a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs index 78522532..b688cda8 100644 --- a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat3x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_zero() { TestUtils.AreEqual(0.0f, float3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void float3x4_zero() TestUtils.AreEqual(0.0f, float3x4.zero.c3.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_equal_wide_wide() { float3x4 a0 = float3x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f); @@ -56,7 +56,7 @@ public static void float3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_equal_wide_scalar() { float3x4 a0 = float3x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f); @@ -80,7 +80,7 @@ public static void float3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -104,7 +104,7 @@ public static void float3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_not_equal_wide_wide() { float3x4 a0 = float3x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f); @@ -128,7 +128,7 @@ public static void float3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_not_equal_wide_scalar() { float3x4 a0 = float3x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f); @@ -152,7 +152,7 @@ public static void float3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -176,7 +176,7 @@ public static void float3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_less_wide_wide() { float3x4 a0 = float3x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f); @@ -200,7 +200,7 @@ public static void float3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_less_wide_scalar() { float3x4 a0 = float3x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f); @@ -224,7 +224,7 @@ public static void float3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -248,7 +248,7 @@ public static void float3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_greater_wide_wide() { float3x4 a0 = float3x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f); @@ -272,7 +272,7 @@ public static void float3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_greater_wide_scalar() { float3x4 a0 = float3x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f); @@ -296,7 +296,7 @@ public static void float3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -320,7 +320,7 @@ public static void float3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_less_equal_wide_wide() { float3x4 a0 = float3x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f); @@ -344,7 +344,7 @@ public static void float3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_less_equal_wide_scalar() { float3x4 a0 = float3x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f); @@ -368,7 +368,7 @@ public static void float3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -392,7 +392,7 @@ public static void float3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_greater_equal_wide_wide() { float3x4 a0 = float3x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f); @@ -416,7 +416,7 @@ public static void float3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_greater_equal_wide_scalar() { float3x4 a0 = float3x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f); @@ -440,7 +440,7 @@ public static void float3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -464,7 +464,7 @@ public static void float3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_add_wide_wide() { float3x4 a0 = float3x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f); @@ -488,7 +488,7 @@ public static void float3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_add_wide_scalar() { float3x4 a0 = float3x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f); @@ -512,7 +512,7 @@ public static void float3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -536,7 +536,7 @@ public static void float3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_sub_wide_wide() { float3x4 a0 = float3x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f); @@ -560,7 +560,7 @@ public static void float3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_sub_wide_scalar() { float3x4 a0 = float3x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f); @@ -584,7 +584,7 @@ public static void float3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -608,7 +608,7 @@ public static void float3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_mul_wide_wide() { float3x4 a0 = float3x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f); @@ -632,7 +632,7 @@ public static void float3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_mul_wide_scalar() { float3x4 a0 = float3x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f); @@ -656,7 +656,7 @@ public static void float3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -680,7 +680,7 @@ public static void float3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_div_wide_wide() { float3x4 a0 = float3x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f); @@ -704,7 +704,7 @@ public static void float3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_div_wide_scalar() { float3x4 a0 = float3x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f); @@ -728,7 +728,7 @@ public static void float3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -752,7 +752,7 @@ public static void float3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_mod_wide_wide() { float3x4 a0 = float3x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f); @@ -776,7 +776,7 @@ public static void float3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_mod_wide_scalar() { float3x4 a0 = float3x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f); @@ -800,7 +800,7 @@ public static void float3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -824,7 +824,7 @@ public static void float3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_plus() { float3x4 a0 = float3x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f); @@ -844,7 +844,7 @@ public static void float3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_neg() { float3x4 a0 = float3x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f); @@ -864,7 +864,7 @@ public static void float3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_prefix_inc() { float3x4 a0 = float3x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f); @@ -884,7 +884,7 @@ public static void float3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_postfix_inc() { float3x4 a0 = float3x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f); @@ -904,7 +904,7 @@ public static void float3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_prefix_dec() { float3x4 a0 = float3x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f); @@ -924,7 +924,7 @@ public static void float3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_operator_postfix_dec() { float3x4 a0 = float3x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f); diff --git a/src/Tests/Tests/Shared/TestFloat4.gen.cs b/src/Tests/Tests/Shared/TestFloat4.gen.cs index 9ac6757c..1e0d3ab1 100644 --- a/src/Tests/Tests/Shared/TestFloat4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_zero() { TestUtils.AreEqual(0.0f, float4.zero.x); @@ -24,7 +24,7 @@ public static void float4_zero() TestUtils.AreEqual(0.0f, float4.zero.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_constructor() { float4 a = new float4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void float4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_scalar_constructor() { float4 a = new float4(17.0f); @@ -44,7 +44,7 @@ public static void float4_scalar_constructor() TestUtils.AreEqual(17.0f, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_static_constructor() { float4 a = float4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void float4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_static_scalar_constructor() { float4 a = float4(17.0f); @@ -64,7 +64,7 @@ public static void float4_static_scalar_constructor() TestUtils.AreEqual(17.0f, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_equal_wide_wide() { float4 a0 = float4(492.1576f, -495.206329f, 227.457642f, -147.374054f); @@ -88,7 +88,7 @@ public static void float4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_equal_wide_scalar() { float4 a0 = float4(-303.230072f, 451.5263f, -253.655884f, -105.203644f); @@ -112,7 +112,7 @@ public static void float4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -136,7 +136,7 @@ public static void float4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_not_equal_wide_wide() { float4 a0 = float4(430.842529f, 104.69f, 225.802429f, -310.5702f); @@ -160,7 +160,7 @@ public static void float4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_not_equal_wide_scalar() { float4 a0 = float4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f); @@ -184,7 +184,7 @@ public static void float4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -208,7 +208,7 @@ public static void float4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_less_wide_wide() { float4 a0 = float4(196.84259f, 336.4098f, 251.963745f, 257.655945f); @@ -232,7 +232,7 @@ public static void float4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_less_wide_scalar() { float4 a0 = float4(-132.057312f, -192.465f, -66.8345947f, -379.017517f); @@ -256,7 +256,7 @@ public static void float4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -280,7 +280,7 @@ public static void float4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_greater_wide_wide() { float4 a0 = float4(483.5014f, 310.8156f, 106.966187f, 295.7353f); @@ -304,7 +304,7 @@ public static void float4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_greater_wide_scalar() { float4 a0 = float4(64.31793f, -397.703461f, 431.8769f, 85.703f); @@ -328,7 +328,7 @@ public static void float4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -352,7 +352,7 @@ public static void float4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_less_equal_wide_wide() { float4 a0 = float4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f); @@ -376,7 +376,7 @@ public static void float4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_less_equal_wide_scalar() { float4 a0 = float4(193.49585f, 168.915527f, -313.993073f, 81.8269653f); @@ -400,7 +400,7 @@ public static void float4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -424,7 +424,7 @@ public static void float4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_greater_equal_wide_wide() { float4 a0 = float4(-507.9286f, 504.4975f, -385.4345f, -262.323425f); @@ -448,7 +448,7 @@ public static void float4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_greater_equal_wide_scalar() { float4 a0 = float4(465.152161f, -424.886078f, -209.2211f, 58.7798462f); @@ -472,7 +472,7 @@ public static void float4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -496,7 +496,7 @@ public static void float4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_add_wide_wide() { float4 a0 = float4(506.129028f, -501.779816f, 420.084778f, -186.032074f); @@ -520,7 +520,7 @@ public static void float4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_add_wide_scalar() { float4 a0 = float4(-194.514191f, 338.5484f, 246.971375f, 100.510925f); @@ -544,7 +544,7 @@ public static void float4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -568,7 +568,7 @@ public static void float4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_sub_wide_wide() { float4 a0 = float4(160.492249f, 11.223938f, 359.200134f, -498.2283f); @@ -592,7 +592,7 @@ public static void float4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_sub_wide_scalar() { float4 a0 = float4(207.389587f, 248.457764f, -384.8239f, -205.344757f); @@ -616,7 +616,7 @@ public static void float4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -640,7 +640,7 @@ public static void float4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_mul_wide_wide() { float4 a0 = float4(-482.7138f, -407.2935f, 137.700562f, 208.541138f); @@ -664,7 +664,7 @@ public static void float4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_mul_wide_scalar() { float4 a0 = float4(-96.31882f, -277.142273f, -239.93689f, 509.531433f); @@ -688,7 +688,7 @@ public static void float4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -712,7 +712,7 @@ public static void float4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_div_wide_wide() { float4 a0 = float4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f); @@ -736,7 +736,7 @@ public static void float4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_div_wide_scalar() { float4 a0 = float4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f); @@ -760,7 +760,7 @@ public static void float4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -784,7 +784,7 @@ public static void float4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_mod_wide_wide() { float4 a0 = float4(-388.8125f, 181.681213f, -167.078735f, 432.820129f); @@ -808,7 +808,7 @@ public static void float4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_mod_wide_scalar() { float4 a0 = float4(-244.499634f, -211.8193f, -145.926788f, -304.9182f); @@ -832,7 +832,7 @@ public static void float4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -856,7 +856,7 @@ public static void float4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_plus() { float4 a0 = float4(-418.829559f, -405.79895f, -34.04178f, 236.999268f); @@ -876,7 +876,7 @@ public static void float4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_neg() { float4 a0 = float4(148.461731f, -467.122681f, 132.04718f, 183.522644f); @@ -896,7 +896,7 @@ public static void float4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_prefix_inc() { float4 a0 = float4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f); @@ -916,7 +916,7 @@ public static void float4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_postfix_inc() { float4 a0 = float4(-396.669739f, 511.20752f, 249.111267f, -128.817322f); @@ -936,7 +936,7 @@ public static void float4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_prefix_dec() { float4 a0 = float4(123.128723f, 256.84375f, 156.330811f, 461.737427f); @@ -956,7 +956,7 @@ public static void float4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_operator_postfix_dec() { float4 a0 = float4(379.6883f, 302.692871f, -176.07135f, -291.2527f); @@ -976,7 +976,7 @@ public static void float4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_shuffle_result_1() { float4 a = float4(0, 1, 2, 3); @@ -992,7 +992,7 @@ public static void float4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_shuffle_result_2() { float4 a = float4(0, 1, 2, 3); @@ -1016,7 +1016,7 @@ public static void float4_shuffle_result_2() TestUtils.AreEqual(float2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_shuffle_result_3() { float4 a = float4(0, 1, 2, 3); @@ -1040,7 +1040,7 @@ public static void float4_shuffle_result_3() TestUtils.AreEqual(float3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_shuffle_result_4() { float4 a = float4(0, 1, 2, 3); diff --git a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs index 492a62f9..9b0cd505 100644 --- a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_zero() { TestUtils.AreEqual(0.0f, float4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void float4x2_zero() TestUtils.AreEqual(0.0f, float4x2.zero.c1.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_equal_wide_wide() { float4x2 a0 = float4x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f); @@ -52,7 +52,7 @@ public static void float4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_equal_wide_scalar() { float4x2 a0 = float4x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f); @@ -76,7 +76,7 @@ public static void float4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -100,7 +100,7 @@ public static void float4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_not_equal_wide_wide() { float4x2 a0 = float4x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f); @@ -124,7 +124,7 @@ public static void float4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_not_equal_wide_scalar() { float4x2 a0 = float4x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f); @@ -148,7 +148,7 @@ public static void float4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -172,7 +172,7 @@ public static void float4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_less_wide_wide() { float4x2 a0 = float4x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f); @@ -196,7 +196,7 @@ public static void float4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_less_wide_scalar() { float4x2 a0 = float4x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f); @@ -220,7 +220,7 @@ public static void float4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -244,7 +244,7 @@ public static void float4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_greater_wide_wide() { float4x2 a0 = float4x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f); @@ -268,7 +268,7 @@ public static void float4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_greater_wide_scalar() { float4x2 a0 = float4x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f); @@ -292,7 +292,7 @@ public static void float4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -316,7 +316,7 @@ public static void float4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_less_equal_wide_wide() { float4x2 a0 = float4x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f); @@ -340,7 +340,7 @@ public static void float4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_less_equal_wide_scalar() { float4x2 a0 = float4x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f); @@ -364,7 +364,7 @@ public static void float4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -388,7 +388,7 @@ public static void float4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_greater_equal_wide_wide() { float4x2 a0 = float4x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f); @@ -412,7 +412,7 @@ public static void float4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_greater_equal_wide_scalar() { float4x2 a0 = float4x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f); @@ -436,7 +436,7 @@ public static void float4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -460,7 +460,7 @@ public static void float4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_add_wide_wide() { float4x2 a0 = float4x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f); @@ -484,7 +484,7 @@ public static void float4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_add_wide_scalar() { float4x2 a0 = float4x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f); @@ -508,7 +508,7 @@ public static void float4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -532,7 +532,7 @@ public static void float4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_sub_wide_wide() { float4x2 a0 = float4x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f); @@ -556,7 +556,7 @@ public static void float4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_sub_wide_scalar() { float4x2 a0 = float4x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f); @@ -580,7 +580,7 @@ public static void float4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -604,7 +604,7 @@ public static void float4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_mul_wide_wide() { float4x2 a0 = float4x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f); @@ -628,7 +628,7 @@ public static void float4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_mul_wide_scalar() { float4x2 a0 = float4x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f); @@ -652,7 +652,7 @@ public static void float4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -676,7 +676,7 @@ public static void float4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_div_wide_wide() { float4x2 a0 = float4x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f); @@ -700,7 +700,7 @@ public static void float4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_div_wide_scalar() { float4x2 a0 = float4x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f); @@ -724,7 +724,7 @@ public static void float4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -748,7 +748,7 @@ public static void float4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_mod_wide_wide() { float4x2 a0 = float4x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f); @@ -772,7 +772,7 @@ public static void float4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_mod_wide_scalar() { float4x2 a0 = float4x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f); @@ -796,7 +796,7 @@ public static void float4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -820,7 +820,7 @@ public static void float4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_plus() { float4x2 a0 = float4x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f); @@ -840,7 +840,7 @@ public static void float4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_neg() { float4x2 a0 = float4x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f); @@ -860,7 +860,7 @@ public static void float4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_prefix_inc() { float4x2 a0 = float4x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f); @@ -880,7 +880,7 @@ public static void float4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_postfix_inc() { float4x2 a0 = float4x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f); @@ -900,7 +900,7 @@ public static void float4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_prefix_dec() { float4x2 a0 = float4x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f); @@ -920,7 +920,7 @@ public static void float4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x2_operator_postfix_dec() { float4x2 a0 = float4x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f); diff --git a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs index 06fb08a0..f2d4f21f 100644 --- a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_zero() { TestUtils.AreEqual(0.0f, float4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void float4x3_zero() TestUtils.AreEqual(0.0f, float4x3.zero.c2.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_equal_wide_wide() { float4x3 a0 = float4x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f); @@ -56,7 +56,7 @@ public static void float4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_equal_wide_scalar() { float4x3 a0 = float4x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f); @@ -80,7 +80,7 @@ public static void float4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -104,7 +104,7 @@ public static void float4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_not_equal_wide_wide() { float4x3 a0 = float4x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f); @@ -128,7 +128,7 @@ public static void float4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_not_equal_wide_scalar() { float4x3 a0 = float4x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f); @@ -152,7 +152,7 @@ public static void float4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -176,7 +176,7 @@ public static void float4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_less_wide_wide() { float4x3 a0 = float4x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f); @@ -200,7 +200,7 @@ public static void float4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_less_wide_scalar() { float4x3 a0 = float4x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f); @@ -224,7 +224,7 @@ public static void float4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -248,7 +248,7 @@ public static void float4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_greater_wide_wide() { float4x3 a0 = float4x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f); @@ -272,7 +272,7 @@ public static void float4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_greater_wide_scalar() { float4x3 a0 = float4x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f); @@ -296,7 +296,7 @@ public static void float4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -320,7 +320,7 @@ public static void float4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_less_equal_wide_wide() { float4x3 a0 = float4x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f); @@ -344,7 +344,7 @@ public static void float4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_less_equal_wide_scalar() { float4x3 a0 = float4x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f); @@ -368,7 +368,7 @@ public static void float4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -392,7 +392,7 @@ public static void float4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_greater_equal_wide_wide() { float4x3 a0 = float4x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f); @@ -416,7 +416,7 @@ public static void float4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_greater_equal_wide_scalar() { float4x3 a0 = float4x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f); @@ -440,7 +440,7 @@ public static void float4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -464,7 +464,7 @@ public static void float4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_add_wide_wide() { float4x3 a0 = float4x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f); @@ -488,7 +488,7 @@ public static void float4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_add_wide_scalar() { float4x3 a0 = float4x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f); @@ -512,7 +512,7 @@ public static void float4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -536,7 +536,7 @@ public static void float4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_sub_wide_wide() { float4x3 a0 = float4x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f); @@ -560,7 +560,7 @@ public static void float4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_sub_wide_scalar() { float4x3 a0 = float4x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f); @@ -584,7 +584,7 @@ public static void float4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -608,7 +608,7 @@ public static void float4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_mul_wide_wide() { float4x3 a0 = float4x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f); @@ -632,7 +632,7 @@ public static void float4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_mul_wide_scalar() { float4x3 a0 = float4x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f); @@ -656,7 +656,7 @@ public static void float4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -680,7 +680,7 @@ public static void float4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_div_wide_wide() { float4x3 a0 = float4x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f); @@ -704,7 +704,7 @@ public static void float4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_div_wide_scalar() { float4x3 a0 = float4x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f); @@ -728,7 +728,7 @@ public static void float4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -752,7 +752,7 @@ public static void float4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_mod_wide_wide() { float4x3 a0 = float4x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f); @@ -776,7 +776,7 @@ public static void float4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_mod_wide_scalar() { float4x3 a0 = float4x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f); @@ -800,7 +800,7 @@ public static void float4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -824,7 +824,7 @@ public static void float4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_plus() { float4x3 a0 = float4x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f); @@ -844,7 +844,7 @@ public static void float4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_neg() { float4x3 a0 = float4x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f); @@ -864,7 +864,7 @@ public static void float4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_prefix_inc() { float4x3 a0 = float4x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f); @@ -884,7 +884,7 @@ public static void float4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_postfix_inc() { float4x3 a0 = float4x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f); @@ -904,7 +904,7 @@ public static void float4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_prefix_dec() { float4x3 a0 = float4x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f); @@ -924,7 +924,7 @@ public static void float4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x3_operator_postfix_dec() { float4x3 a0 = float4x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f); diff --git a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs index d7c82665..1e706448 100644 --- a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestFloat4x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_zero() { TestUtils.AreEqual(0.0f, float4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void float4x4_zero() TestUtils.AreEqual(0.0f, float4x4.zero.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_identity() { TestUtils.AreEqual(1.0f, float4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void float4x4_identity() TestUtils.AreEqual(1.0f, float4x4.identity.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_equal_wide_wide() { float4x4 a0 = float4x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f, 109.6344f, 462.6903f, -335.38147f, 357.2345f); @@ -81,7 +81,7 @@ public static void float4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_equal_wide_scalar() { float4x4 a0 = float4x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f, -172.035309f, 455.400024f, -11.3389893f, 363.938232f); @@ -105,7 +105,7 @@ public static void float4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_equal_scalar_wide() { float a0 = (-253.397278f); @@ -129,7 +129,7 @@ public static void float4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_not_equal_wide_wide() { float4x4 a0 = float4x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f, 65.66205f, 102.787781f, 172.930054f, 26.6210327f); @@ -153,7 +153,7 @@ public static void float4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_not_equal_wide_scalar() { float4x4 a0 = float4x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f, -269.805725f, 299.654236f, -71.7509155f, -432.755737f); @@ -177,7 +177,7 @@ public static void float4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_not_equal_scalar_wide() { float a0 = (275.795837f); @@ -201,7 +201,7 @@ public static void float4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_less_wide_wide() { float4x4 a0 = float4x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f, -111.129944f, 70.00549f, 448.1983f, -419.987122f); @@ -225,7 +225,7 @@ public static void float4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_less_wide_scalar() { float4x4 a0 = float4x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f, 373.549683f, 398.523682f, 105.030151f, -58.0108948f); @@ -249,7 +249,7 @@ public static void float4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_less_scalar_wide() { float a0 = (-423.1174f); @@ -273,7 +273,7 @@ public static void float4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_greater_wide_wide() { float4x4 a0 = float4x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f, 455.85144f, 144.706909f, 63.9320068f, -285.683044f); @@ -297,7 +297,7 @@ public static void float4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_greater_wide_scalar() { float4x4 a0 = float4x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f, 370.279175f, -413.7014f, -356.592346f, -353.0313f); @@ -321,7 +321,7 @@ public static void float4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_greater_scalar_wide() { float a0 = (-282.6705f); @@ -345,7 +345,7 @@ public static void float4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_less_equal_wide_wide() { float4x4 a0 = float4x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f, 149.736511f, -418.8867f, -197.502533f, -88.2055054f); @@ -369,7 +369,7 @@ public static void float4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_less_equal_wide_scalar() { float4x4 a0 = float4x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f, -264.9378f, 82.2583f, 11.2460327f, 424.704041f); @@ -393,7 +393,7 @@ public static void float4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_less_equal_scalar_wide() { float a0 = (393.606262f); @@ -417,7 +417,7 @@ public static void float4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_greater_equal_wide_wide() { float4x4 a0 = float4x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f, -309.570221f, -136.022491f, 280.736267f, -96.99588f); @@ -441,7 +441,7 @@ public static void float4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_greater_equal_wide_scalar() { float4x4 a0 = float4x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f, -36.9942932f, 494.8203f, -164.973938f, -466.1201f); @@ -465,7 +465,7 @@ public static void float4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_greater_equal_scalar_wide() { float a0 = (374.827026f); @@ -489,7 +489,7 @@ public static void float4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_add_wide_wide() { float4x4 a0 = float4x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f, 69.19568f, -177.957336f, 299.604126f, 340.704834f); @@ -513,7 +513,7 @@ public static void float4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_add_wide_scalar() { float4x4 a0 = float4x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f, -188.265015f, -213.526733f, -267.7843f, 189.259949f); @@ -537,7 +537,7 @@ public static void float4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_add_scalar_wide() { float a0 = (-340.354675f); @@ -561,7 +561,7 @@ public static void float4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_sub_wide_wide() { float4x4 a0 = float4x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f, 24.8754272f, 366.614441f, -107.374146f, -219.008148f); @@ -585,7 +585,7 @@ public static void float4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_sub_wide_scalar() { float4x4 a0 = float4x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f, 349.397766f, 439.077271f, 490.2223f, 195.024048f); @@ -609,7 +609,7 @@ public static void float4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_sub_scalar_wide() { float a0 = (-86.00824f); @@ -633,7 +633,7 @@ public static void float4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_mul_wide_wide() { float4x4 a0 = float4x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f, -262.682556f, -379.262756f, -374.090576f, 481.4474f); @@ -657,7 +657,7 @@ public static void float4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_mul_wide_scalar() { float4x4 a0 = float4x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f, -207.3501f, -383.9396f, -31.4252319f, 42.6761475f); @@ -681,7 +681,7 @@ public static void float4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_mul_scalar_wide() { float a0 = (37.43219f); @@ -705,7 +705,7 @@ public static void float4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_div_wide_wide() { float4x4 a0 = float4x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f, -416.226135f, -450.0192f, -273.497437f, -286.908173f); @@ -729,7 +729,7 @@ public static void float4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_div_wide_scalar() { float4x4 a0 = float4x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f, -205.033813f, 481.738159f, 464.479065f, -293.4635f); @@ -753,7 +753,7 @@ public static void float4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_div_scalar_wide() { float a0 = (-264.4425f); @@ -777,7 +777,7 @@ public static void float4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_mod_wide_wide() { float4x4 a0 = float4x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f, -124.033722f, 259.274f, -274.358459f, -140.030792f); @@ -801,7 +801,7 @@ public static void float4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_mod_wide_scalar() { float4x4 a0 = float4x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f, -355.846863f, 259.378f, -330.871948f, -284.343567f); @@ -825,7 +825,7 @@ public static void float4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_mod_scalar_wide() { float a0 = (-66.94504f); @@ -849,7 +849,7 @@ public static void float4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_plus() { float4x4 a0 = float4x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f, -170.746521f, 439.5594f, -478.7494f, 116.400757f); @@ -869,7 +869,7 @@ public static void float4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_neg() { float4x4 a0 = float4x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f, 466.441528f, 171.902466f, -280.558319f, -78.857605f); @@ -889,7 +889,7 @@ public static void float4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_prefix_inc() { float4x4 a0 = float4x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f, 243.546936f, 46.1920166f, -41.4972839f, 299.1855f); @@ -909,7 +909,7 @@ public static void float4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_postfix_inc() { float4x4 a0 = float4x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f, 128.5304f, 73.15558f, -60.1323853f, -446.229767f); @@ -929,7 +929,7 @@ public static void float4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_prefix_dec() { float4x4 a0 = float4x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f, -363.0755f, -22.0289612f, 248.7901f, 168.095032f); @@ -949,7 +949,7 @@ public static void float4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_operator_postfix_dec() { float4x4 a0 = float4x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f, -200.304291f, -445.026947f, 407.420349f, 327.670349f); diff --git a/src/Tests/Tests/Shared/TestHalf.cs b/src/Tests/Tests/Shared/TestHalf.cs index 301e06d2..7cd3e330 100644 --- a/src/Tests/Tests/Shared/TestHalf.cs +++ b/src/Tests/Tests/Shared/TestHalf.cs @@ -8,20 +8,20 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestHalf { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_zero() { TestUtils.AreEqual(0x0000, half.zero.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_zero() { TestUtils.AreEqual(0x0000, half2.zero.x.value); TestUtils.AreEqual(0x0000, half2.zero.y.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_zero() { TestUtils.AreEqual(0x0000, half3.zero.x.value); @@ -29,7 +29,7 @@ public static void half3_zero() TestUtils.AreEqual(0x0000, half3.zero.z.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_zero() { TestUtils.AreEqual(0x0000, half4.zero.x.value); @@ -38,7 +38,7 @@ public static void half4_zero() TestUtils.AreEqual(0x0000, half4.zero.w.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_from_float_construction() { TestUtils.AreEqual(0x0000, half(0.0f).value); @@ -58,14 +58,14 @@ public static void half_from_float_construction() TestUtils.AreEqual(0xFC00, half(float.NegativeInfinity).value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half_from_float_construction_signed_zero() { TestUtils.AreEqual(0x8000, half(TestUtils.SignedFloatZero()).value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_from_float2_construction() { half2 h0 = half2(float2(0.0f, 2.98e-08f)); @@ -89,7 +89,7 @@ public static void half2_from_float2_construction() TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half2_from_float2_construction_signed_zero() { @@ -97,7 +97,7 @@ public static void half2_from_float2_construction_signed_zero() TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_from_float3_construction() { half3 h0 = half3(float3(0.0f, 2.98e-08f, 5.96046448e-08f)); @@ -114,7 +114,7 @@ public static void half3_from_float3_construction() TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half3_from_float3_construction_signed_zero() { @@ -122,7 +122,7 @@ public static void half3_from_float3_construction_signed_zero() TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_from_float4_construction() { half4 h0 = half4(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f)); @@ -136,7 +136,7 @@ public static void half4_from_float4_construction() TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half4_from_float4_construction_signed_zero() { @@ -145,7 +145,7 @@ public static void half4_from_float4_construction_signed_zero() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_from_double_construction() { TestUtils.AreEqual(0x0000, half(0.0).value); @@ -165,14 +165,14 @@ public static void half_from_double_construction() TestUtils.AreEqual(0xFC00, half(double.NegativeInfinity).value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half_from_double_construction_signed_zero() { TestUtils.AreEqual(0x8000, half(TestUtils.SignedDoubleZero()).value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_from_double2_construction() { half2 h0 = half2(double2(0.0, 2.98e-08)); @@ -196,7 +196,7 @@ public static void half2_from_double2_construction() TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half2_from_double2_construction_signed_zero() { @@ -204,7 +204,7 @@ public static void half2_from_double2_construction_signed_zero() TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_from_double3_construction() { half3 h0 = half3(double3(0.0, 2.98e-08, 5.96046448e-08)); @@ -221,7 +221,7 @@ public static void half3_from_double3_construction() TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half3_from_double3_construction_signed_zero() { @@ -229,7 +229,7 @@ public static void half3_from_double3_construction_signed_zero() TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_from_double4_construction() { half4 h0 = half4(double4(0.0, 2.98e-08, 5.96046448e-08, 123.4)); @@ -243,7 +243,7 @@ public static void half4_from_double4_construction() TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void half4_from_double4_construction_signed_zero() { @@ -251,7 +251,7 @@ public static void half4_from_double4_construction_signed_zero() TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_to_float() { TestUtils.AreEqual(0x00000000, asuint(new half { value = 0x0000 })); @@ -269,7 +269,7 @@ public static void half_to_float() TestUtils.AreEqual(true, isnan(new half { value = 0xFC01 })); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_to_float2() { half2 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; @@ -293,7 +293,7 @@ public static void half2_to_float2() TestUtils.AreEqual(true, all(isnan(h7))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_to_float3() { half3 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; @@ -313,7 +313,7 @@ public static void half3_to_float3() TestUtils.AreEqual(true, all(isnan(h5))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_to_float4() { half4 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; h0.w.value = 0x7BFF; @@ -334,7 +334,7 @@ public static void half4_to_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_to_double() { TestUtils.AreEqual(0x0000000000000000u, asulong((double)new half { value = 0x0000 })); @@ -353,14 +353,14 @@ public static void half_to_double() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_from_float_explicit_conversion() { half h = (half)123.4f; TestUtils.AreEqual(0x57B6, h.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_from_float2_explicit_conversion() { half2 h = (half2)float2(123.4f, 5.96046448e-08f); @@ -368,7 +368,7 @@ public static void half2_from_float2_explicit_conversion() TestUtils.AreEqual(0x0001, h.y.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_from_float3_explicit_conversion() { half3 h = (half3)float3(123.4f, 5.96046448e-08f, -65504.0f); @@ -377,7 +377,7 @@ public static void half3_from_float3_explicit_conversion() TestUtils.AreEqual(0xFBFF, h.z.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_from_float4_explicit_conversion() { half4 h = (half4)float4(123.4f, 5.96046448e-08f, -65504.0f, float.PositiveInfinity); @@ -387,7 +387,7 @@ public static void half4_from_float4_explicit_conversion() TestUtils.AreEqual(0x7C00, h.w.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_from_double_explicit_conversion() { half h = (half)123.4; @@ -395,7 +395,7 @@ public static void half_from_double_explicit_conversion() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_to_float_implicit_conversion() { half h; h.value = 0x0203; @@ -403,7 +403,7 @@ public static void half_to_float_implicit_conversion() TestUtils.AreEqual(0x3800C000, asuint(f)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_to_float2_implicit_conversion() { half2 h; h.x.value = 0x0203; h.y.value = 0x8203; @@ -412,7 +412,7 @@ public static void half2_to_float2_implicit_conversion() TestUtils.AreEqual(0xB800C000, asuint(f.y)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_to_float3_implicit_conversion() { half3 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; @@ -422,7 +422,7 @@ public static void half3_to_float3_implicit_conversion() TestUtils.AreEqual(0x477FE000, asuint(f.z)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_to_float4_implicit_conversion() { half4 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; h.w.value = 0x7C00; @@ -433,7 +433,7 @@ public static void half4_to_float4_implicit_conversion() TestUtils.AreEqual(0x7F800000, asuint(f.w)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_to_double_implicit_conversion() { half h; h.value = 0x0203; @@ -442,33 +442,33 @@ public static void half_to_double_implicit_conversion() TestUtils.AreEqual(0x3F00180000000000u, asulong(f)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_minvalue() { half min = new half(half.MinValue); TestUtils.AreEqual(0xfbff, min.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_maxvalue() { half max = new half(half.MaxValue); TestUtils.AreEqual(0x7bff, max.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_minvalueashalf() { TestUtils.AreEqual(0xfbff, half.MinValueAsHalf.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half_maxvalueashalf() { TestUtils.AreEqual(0x7bff, half.MaxValueAsHalf.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_minvalue() { half2 min = half.MinValueAsHalf; @@ -476,7 +476,7 @@ public static void half2_minvalue() TestUtils.AreEqual(0xfbff, min.y.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half2_maxvalue() { half2 max = half.MaxValueAsHalf; @@ -484,7 +484,7 @@ public static void half2_maxvalue() TestUtils.AreEqual(0x7bff, max.y.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_minvalue() { half3 min = half.MinValueAsHalf; @@ -493,7 +493,7 @@ public static void half3_minvalue() TestUtils.AreEqual(0xfbff, min.z.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half3_maxvalue() { half3 max = half.MaxValueAsHalf; @@ -502,7 +502,7 @@ public static void half3_maxvalue() TestUtils.AreEqual(0x7bff, max.z.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_minvalue() { half4 min = half.MinValueAsHalf; @@ -512,7 +512,7 @@ public static void half4_minvalue() TestUtils.AreEqual(0xfbff, min.w.value); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void half4_maxvalue() { half4 max = half.MaxValueAsHalf; diff --git a/src/Tests/Tests/Shared/TestInt2.gen.cs b/src/Tests/Tests/Shared/TestInt2.gen.cs index 6196c993..75f6aba0 100644 --- a/src/Tests/Tests/Shared/TestInt2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_zero() { TestUtils.AreEqual(0, int2.zero.x); TestUtils.AreEqual(0, int2.zero.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_constructor() { int2 a = new int2(1, 2); @@ -30,7 +30,7 @@ public static void int2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_scalar_constructor() { int2 a = new int2(17); @@ -38,7 +38,7 @@ public static void int2_scalar_constructor() TestUtils.AreEqual(17, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_static_constructor() { int2 a = int2(1, 2); @@ -46,7 +46,7 @@ public static void int2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_static_scalar_constructor() { int2 a = int2(17); @@ -54,7 +54,7 @@ public static void int2_static_scalar_constructor() TestUtils.AreEqual(17, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_equal_wide_wide() { int2 a0 = int2(2105871082, 35218899); @@ -78,7 +78,7 @@ public static void int2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_equal_wide_scalar() { int2 a0 = int2(437822262, 2020661134); @@ -102,7 +102,7 @@ public static void int2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -126,7 +126,7 @@ public static void int2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_not_equal_wide_wide() { int2 a0 = int2(1977284100, 1293292704); @@ -150,7 +150,7 @@ public static void int2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_not_equal_wide_scalar() { int2 a0 = int2(1038269360, 1427812625); @@ -174,7 +174,7 @@ public static void int2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -198,7 +198,7 @@ public static void int2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_less_wide_wide() { int2 a0 = int2(1486550609, 1779244308); @@ -222,7 +222,7 @@ public static void int2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_less_wide_scalar() { int2 a0 = int2(796797557, 670113454); @@ -246,7 +246,7 @@ public static void int2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_less_scalar_wide() { int a0 = (186400299); @@ -270,7 +270,7 @@ public static void int2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_greater_wide_wide() { int2 a0 = int2(2087717754, 1725569452); @@ -294,7 +294,7 @@ public static void int2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_greater_wide_scalar() { int2 a0 = int2(1208626274, 239697208); @@ -318,7 +318,7 @@ public static void int2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -342,7 +342,7 @@ public static void int2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_less_equal_wide_wide() { int2 a0 = int2(154092149, 1515170149); @@ -366,7 +366,7 @@ public static void int2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_less_equal_wide_scalar() { int2 a0 = int2(1479531977, 1427983411); @@ -390,7 +390,7 @@ public static void int2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -414,7 +414,7 @@ public static void int2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_greater_equal_wide_wide() { int2 a0 = int2(8538378, 2131749726); @@ -438,7 +438,7 @@ public static void int2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_greater_equal_wide_scalar() { int2 a0 = int2(2049236663, 182691143); @@ -462,7 +462,7 @@ public static void int2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -486,7 +486,7 @@ public static void int2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_add_wide_wide() { int2 a0 = int2(2135171378, 21433296); @@ -510,7 +510,7 @@ public static void int2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_add_wide_scalar() { int2 a0 = int2(665815972, 1783729250); @@ -534,7 +534,7 @@ public static void int2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_add_scalar_wide() { int a0 = (359966320); @@ -558,7 +558,7 @@ public static void int2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_sub_wide_wide() { int2 a0 = int2(1410318491, 1097280168); @@ -582,7 +582,7 @@ public static void int2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_sub_wide_scalar() { int2 a0 = int2(1508669340, 1594795463); @@ -606,7 +606,7 @@ public static void int2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -630,7 +630,7 @@ public static void int2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_mul_wide_wide() { int2 a0 = int2(61417577, 219585476); @@ -654,7 +654,7 @@ public static void int2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_mul_wide_scalar() { int2 a0 = int2(871746615, 492532311); @@ -678,7 +678,7 @@ public static void int2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -702,7 +702,7 @@ public static void int2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_div_wide_wide() { int2 a0 = int2(333171510, 858154903); @@ -726,7 +726,7 @@ public static void int2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_div_wide_scalar() { int2 a0 = int2(1433072926, 1073958635); @@ -750,7 +750,7 @@ public static void int2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_div_scalar_wide() { int a0 = (519165704); @@ -774,7 +774,7 @@ public static void int2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_mod_wide_wide() { int2 a0 = int2(258342924, 1454754891); @@ -798,7 +798,7 @@ public static void int2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_mod_wide_scalar() { int2 a0 = int2(560988938, 629524514); @@ -822,7 +822,7 @@ public static void int2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -846,7 +846,7 @@ public static void int2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_plus() { int2 a0 = int2(195392567, 222719748); @@ -866,7 +866,7 @@ public static void int2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_neg() { int2 a0 = int2(1385088677, 94114564); @@ -886,7 +886,7 @@ public static void int2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_prefix_inc() { int2 a0 = int2(780471723, 954741756); @@ -906,7 +906,7 @@ public static void int2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_postfix_inc() { int2 a0 = int2(241865086, 2145821641); @@ -926,7 +926,7 @@ public static void int2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_prefix_dec() { int2 a0 = int2(1331961415, 1612382200); @@ -946,7 +946,7 @@ public static void int2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_postfix_dec() { int2 a0 = int2(1870005937, 1708534798); @@ -966,7 +966,7 @@ public static void int2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_and_wide_wide() { int2 a0 = int2(1055241304, 859321394); @@ -990,7 +990,7 @@ public static void int2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_and_wide_scalar() { int2 a0 = int2(1513158868, 284695609); @@ -1014,7 +1014,7 @@ public static void int2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1038,7 +1038,7 @@ public static void int2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_or_wide_wide() { int2 a0 = int2(1920951869, 1750772852); @@ -1062,7 +1062,7 @@ public static void int2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_or_wide_scalar() { int2 a0 = int2(1295304853, 1307252624); @@ -1086,7 +1086,7 @@ public static void int2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1110,7 +1110,7 @@ public static void int2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_xor_wide_wide() { int2 a0 = int2(1843655608, 362425681); @@ -1134,7 +1134,7 @@ public static void int2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_xor_wide_scalar() { int2 a0 = int2(169345668, 176087064); @@ -1158,7 +1158,7 @@ public static void int2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1182,7 +1182,7 @@ public static void int2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_left_shift() { int2 a0 = int2(1129100049, 829482269); @@ -1206,7 +1206,7 @@ public static void int2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_right_shift() { int2 a0 = int2(809126085, 908563670); @@ -1230,7 +1230,7 @@ public static void int2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_operator_bitwise_not() { int2 a0 = int2(111796841, 603562399); @@ -1250,7 +1250,7 @@ public static void int2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_shuffle_result_1() { int2 a = int2(0, 1); @@ -1262,7 +1262,7 @@ public static void int2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_shuffle_result_2() { int2 a = int2(0, 1); @@ -1286,7 +1286,7 @@ public static void int2_shuffle_result_2() TestUtils.AreEqual(int2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_shuffle_result_3() { int2 a = int2(0, 1); @@ -1310,7 +1310,7 @@ public static void int2_shuffle_result_3() TestUtils.AreEqual(int3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_shuffle_result_4() { int2 a = int2(0, 1); diff --git a/src/Tests/Tests/Shared/TestInt2x2.gen.cs b/src/Tests/Tests/Shared/TestInt2x2.gen.cs index a99dd57e..754451d3 100644 --- a/src/Tests/Tests/Shared/TestInt2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_zero() { TestUtils.AreEqual(0, int2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void int2x2_zero() TestUtils.AreEqual(0, int2x2.zero.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_identity() { TestUtils.AreEqual(1, int2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void int2x2_identity() TestUtils.AreEqual(1, int2x2.identity.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_equal_wide_wide() { int2x2 a0 = int2x2(2105871082, 35218899, 1550755093, 764676020); @@ -57,7 +57,7 @@ public static void int2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_equal_wide_scalar() { int2x2 a0 = int2x2(437822262, 2020661134, 541786900, 853113810); @@ -81,7 +81,7 @@ public static void int2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -105,7 +105,7 @@ public static void int2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_not_equal_wide_wide() { int2x2 a0 = int2x2(1977284100, 1293292704, 1547283851, 422428953); @@ -129,7 +129,7 @@ public static void int2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_not_equal_wide_scalar() { int2x2 a0 = int2x2(1038269360, 1427812625, 103361237, 1347017023); @@ -153,7 +153,7 @@ public static void int2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -177,7 +177,7 @@ public static void int2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_less_wide_wide() { int2x2 a0 = int2x2(1486550609, 1779244308, 1602148045, 1614085440); @@ -201,7 +201,7 @@ public static void int2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_less_wide_scalar() { int2x2 a0 = int2x2(796797557, 670113454, 933579492, 278884514); @@ -225,7 +225,7 @@ public static void int2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_less_scalar_wide() { int a0 = (186400299); @@ -249,7 +249,7 @@ public static void int2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_greater_wide_wide() { int2x2 a0 = int2x2(2087717754, 1725569452, 1298066182, 1693943616); @@ -273,7 +273,7 @@ public static void int2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_greater_wide_scalar() { int2x2 a0 = int2x2(1208626274, 239697208, 1979453345, 1253474001); @@ -297,7 +297,7 @@ public static void int2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -321,7 +321,7 @@ public static void int2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_less_equal_wide_wide() { int2x2 a0 = int2x2(154092149, 1515170149, 1083970332, 785807178); @@ -345,7 +345,7 @@ public static void int2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_less_equal_wide_scalar() { int2x2 a0 = int2x2(1479531977, 1427983411, 415250630, 1245345407); @@ -369,7 +369,7 @@ public static void int2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -393,7 +393,7 @@ public static void int2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_greater_equal_wide_wide() { int2x2 a0 = int2x2(8538378, 2131749726, 265427108, 523609761); @@ -417,7 +417,7 @@ public static void int2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_greater_equal_wide_scalar() { int2x2 a0 = int2x2(2049236663, 182691143, 634973382, 1197012109); @@ -441,7 +441,7 @@ public static void int2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -465,7 +465,7 @@ public static void int2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_add_wide_wide() { int2x2 a0 = int2x2(2135171378, 21433296, 1954723494, 683604307); @@ -489,7 +489,7 @@ public static void int2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_add_wide_scalar() { int2x2 a0 = int2x2(665815972, 1783729250, 1591678394, 1284528538); @@ -513,7 +513,7 @@ public static void int2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_add_scalar_wide() { int a0 = (359966320); @@ -537,7 +537,7 @@ public static void int2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_sub_wide_wide() { int2x2 a0 = int2x2(1410318491, 1097280168, 1827039044, 28881338); @@ -561,7 +561,7 @@ public static void int2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_sub_wide_scalar() { int2x2 a0 = int2x2(1508669340, 1594795463, 266707545, 643102647); @@ -585,7 +585,7 @@ public static void int2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -609,7 +609,7 @@ public static void int2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_mul_wide_wide() { int2x2 a0 = int2x2(61417577, 219585476, 1362520891, 1511084277); @@ -633,7 +633,7 @@ public static void int2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_mul_wide_scalar() { int2x2 a0 = int2x2(871746615, 492532311, 570557670, 2142306629); @@ -657,7 +657,7 @@ public static void int2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -681,7 +681,7 @@ public static void int2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_div_wide_wide() { int2x2 a0 = int2x2(333171510, 858154903, 1181365836, 671357749); @@ -705,7 +705,7 @@ public static void int2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_div_wide_scalar() { int2x2 a0 = int2x2(1433072926, 1073958635, 1195142312, 536596719); @@ -729,7 +729,7 @@ public static void int2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_div_scalar_wide() { int a0 = (519165704); @@ -753,7 +753,7 @@ public static void int2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_mod_wide_wide() { int2x2 a0 = int2x2(258342924, 1454754891, 723352342, 1981431473); @@ -777,7 +777,7 @@ public static void int2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_mod_wide_scalar() { int2x2 a0 = int2x2(560988938, 629524514, 767711194, 434281967); @@ -801,7 +801,7 @@ public static void int2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -825,7 +825,7 @@ public static void int2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_plus() { int2x2 a0 = int2x2(195392567, 222719748, 1002351013, 1570765263); @@ -845,7 +845,7 @@ public static void int2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_neg() { int2x2 a0 = int2x2(1385088677, 94114564, 1350664872, 1458616659); @@ -865,7 +865,7 @@ public static void int2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_prefix_inc() { int2x2 a0 = int2x2(780471723, 954741756, 272723451, 2142862245); @@ -885,7 +885,7 @@ public static void int2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_postfix_inc() { int2x2 a0 = int2x2(241865086, 2145821641, 1596166022, 803592338); @@ -905,7 +905,7 @@ public static void int2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_prefix_dec() { int2x2 a0 = int2x2(1331961415, 1612382200, 1401591249, 2042075388); @@ -925,7 +925,7 @@ public static void int2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_postfix_dec() { int2x2 a0 = int2x2(1870005937, 1708534798, 704493460, 462940703); @@ -945,7 +945,7 @@ public static void int2x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_and_wide_wide() { int2x2 a0 = int2x2(1055241304, 859321394, 1088358961, 2090949513); @@ -969,7 +969,7 @@ public static void int2x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_and_wide_scalar() { int2x2 a0 = int2x2(1513158868, 284695609, 734595037, 1566510707); @@ -993,7 +993,7 @@ public static void int2x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1017,7 +1017,7 @@ public static void int2x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_or_wide_wide() { int2x2 a0 = int2x2(1920951869, 1750772852, 1420019191, 732977093); @@ -1041,7 +1041,7 @@ public static void int2x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_or_wide_scalar() { int2x2 a0 = int2x2(1295304853, 1307252624, 350194630, 1128063578); @@ -1065,7 +1065,7 @@ public static void int2x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1089,7 +1089,7 @@ public static void int2x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_xor_wide_wide() { int2x2 a0 = int2x2(1843655608, 362425681, 640805534, 1342040268); @@ -1113,7 +1113,7 @@ public static void int2x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_xor_wide_scalar() { int2x2 a0 = int2x2(169345668, 176087064, 2084362901, 1663924004); @@ -1137,7 +1137,7 @@ public static void int2x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1161,7 +1161,7 @@ public static void int2x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_left_shift() { int2x2 a0 = int2x2(1129100049, 829482269, 1571297368, 443753193); @@ -1185,7 +1185,7 @@ public static void int2x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_right_shift() { int2x2 a0 = int2x2(809126085, 908563670, 763568837, 1986717290); @@ -1209,7 +1209,7 @@ public static void int2x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x2_operator_bitwise_not() { int2x2 a0 = int2x2(111796841, 603562399, 745091931, 853183268); diff --git a/src/Tests/Tests/Shared/TestInt2x3.gen.cs b/src/Tests/Tests/Shared/TestInt2x3.gen.cs index 95b713de..8e25e359 100644 --- a/src/Tests/Tests/Shared/TestInt2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_zero() { TestUtils.AreEqual(0, int2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void int2x3_zero() TestUtils.AreEqual(0, int2x3.zero.c2.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_equal_wide_wide() { int2x3 a0 = int2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void int2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_equal_wide_scalar() { int2x3 a0 = int2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void int2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -98,7 +98,7 @@ public static void int2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_not_equal_wide_wide() { int2x3 a0 = int2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void int2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_not_equal_wide_scalar() { int2x3 a0 = int2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void int2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -170,7 +170,7 @@ public static void int2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_less_wide_wide() { int2x3 a0 = int2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void int2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_less_wide_scalar() { int2x3 a0 = int2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void int2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_less_scalar_wide() { int a0 = (186400299); @@ -242,7 +242,7 @@ public static void int2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_greater_wide_wide() { int2x3 a0 = int2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void int2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_greater_wide_scalar() { int2x3 a0 = int2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void int2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -314,7 +314,7 @@ public static void int2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_less_equal_wide_wide() { int2x3 a0 = int2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void int2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_less_equal_wide_scalar() { int2x3 a0 = int2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void int2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -386,7 +386,7 @@ public static void int2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_greater_equal_wide_wide() { int2x3 a0 = int2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void int2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_greater_equal_wide_scalar() { int2x3 a0 = int2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void int2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -458,7 +458,7 @@ public static void int2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_add_wide_wide() { int2x3 a0 = int2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void int2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_add_wide_scalar() { int2x3 a0 = int2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void int2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_add_scalar_wide() { int a0 = (359966320); @@ -530,7 +530,7 @@ public static void int2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_sub_wide_wide() { int2x3 a0 = int2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void int2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_sub_wide_scalar() { int2x3 a0 = int2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void int2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -602,7 +602,7 @@ public static void int2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_mul_wide_wide() { int2x3 a0 = int2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void int2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_mul_wide_scalar() { int2x3 a0 = int2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void int2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -674,7 +674,7 @@ public static void int2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_div_wide_wide() { int2x3 a0 = int2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void int2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_div_wide_scalar() { int2x3 a0 = int2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void int2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_div_scalar_wide() { int a0 = (519165704); @@ -746,7 +746,7 @@ public static void int2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_mod_wide_wide() { int2x3 a0 = int2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void int2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_mod_wide_scalar() { int2x3 a0 = int2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void int2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -818,7 +818,7 @@ public static void int2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_plus() { int2x3 a0 = int2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void int2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_neg() { int2x3 a0 = int2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void int2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_prefix_inc() { int2x3 a0 = int2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void int2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_postfix_inc() { int2x3 a0 = int2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void int2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_prefix_dec() { int2x3 a0 = int2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void int2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_postfix_dec() { int2x3 a0 = int2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void int2x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_and_wide_wide() { int2x3 a0 = int2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void int2x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_and_wide_scalar() { int2x3 a0 = int2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void int2x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void int2x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_or_wide_wide() { int2x3 a0 = int2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void int2x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_or_wide_scalar() { int2x3 a0 = int2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void int2x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void int2x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_xor_wide_wide() { int2x3 a0 = int2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void int2x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_xor_wide_scalar() { int2x3 a0 = int2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void int2x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void int2x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_left_shift() { int2x3 a0 = int2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void int2x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_right_shift() { int2x3 a0 = int2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void int2x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x3_operator_bitwise_not() { int2x3 a0 = int2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); diff --git a/src/Tests/Tests/Shared/TestInt2x4.gen.cs b/src/Tests/Tests/Shared/TestInt2x4.gen.cs index 8700456f..3fd7b8b3 100644 --- a/src/Tests/Tests/Shared/TestInt2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt2x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_zero() { TestUtils.AreEqual(0, int2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void int2x4_zero() TestUtils.AreEqual(0, int2x4.zero.c3.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_equal_wide_wide() { int2x4 a0 = int2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void int2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_equal_wide_scalar() { int2x4 a0 = int2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void int2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -100,7 +100,7 @@ public static void int2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_not_equal_wide_wide() { int2x4 a0 = int2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void int2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_not_equal_wide_scalar() { int2x4 a0 = int2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void int2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -172,7 +172,7 @@ public static void int2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_less_wide_wide() { int2x4 a0 = int2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void int2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_less_wide_scalar() { int2x4 a0 = int2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void int2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_less_scalar_wide() { int a0 = (186400299); @@ -244,7 +244,7 @@ public static void int2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_greater_wide_wide() { int2x4 a0 = int2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void int2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_greater_wide_scalar() { int2x4 a0 = int2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void int2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -316,7 +316,7 @@ public static void int2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_less_equal_wide_wide() { int2x4 a0 = int2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void int2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_less_equal_wide_scalar() { int2x4 a0 = int2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void int2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -388,7 +388,7 @@ public static void int2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_greater_equal_wide_wide() { int2x4 a0 = int2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void int2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_greater_equal_wide_scalar() { int2x4 a0 = int2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void int2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -460,7 +460,7 @@ public static void int2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_add_wide_wide() { int2x4 a0 = int2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void int2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_add_wide_scalar() { int2x4 a0 = int2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void int2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_add_scalar_wide() { int a0 = (359966320); @@ -532,7 +532,7 @@ public static void int2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_sub_wide_wide() { int2x4 a0 = int2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void int2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_sub_wide_scalar() { int2x4 a0 = int2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void int2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -604,7 +604,7 @@ public static void int2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_mul_wide_wide() { int2x4 a0 = int2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void int2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_mul_wide_scalar() { int2x4 a0 = int2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void int2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -676,7 +676,7 @@ public static void int2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_div_wide_wide() { int2x4 a0 = int2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void int2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_div_wide_scalar() { int2x4 a0 = int2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void int2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_div_scalar_wide() { int a0 = (519165704); @@ -748,7 +748,7 @@ public static void int2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_mod_wide_wide() { int2x4 a0 = int2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void int2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_mod_wide_scalar() { int2x4 a0 = int2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void int2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -820,7 +820,7 @@ public static void int2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_plus() { int2x4 a0 = int2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void int2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_neg() { int2x4 a0 = int2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void int2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_prefix_inc() { int2x4 a0 = int2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void int2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_postfix_inc() { int2x4 a0 = int2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void int2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_prefix_dec() { int2x4 a0 = int2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void int2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_postfix_dec() { int2x4 a0 = int2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void int2x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_and_wide_wide() { int2x4 a0 = int2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void int2x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_and_wide_scalar() { int2x4 a0 = int2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void int2x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void int2x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_or_wide_wide() { int2x4 a0 = int2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void int2x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_or_wide_scalar() { int2x4 a0 = int2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void int2x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void int2x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_xor_wide_wide() { int2x4 a0 = int2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void int2x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_xor_wide_scalar() { int2x4 a0 = int2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void int2x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void int2x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_left_shift() { int2x4 a0 = int2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void int2x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_right_shift() { int2x4 a0 = int2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void int2x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2x4_operator_bitwise_not() { int2x4 a0 = int2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); diff --git a/src/Tests/Tests/Shared/TestInt3.gen.cs b/src/Tests/Tests/Shared/TestInt3.gen.cs index 92b93317..7dac46ed 100644 --- a/src/Tests/Tests/Shared/TestInt3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_zero() { TestUtils.AreEqual(0, int3.zero.x); @@ -23,7 +23,7 @@ public static void int3_zero() TestUtils.AreEqual(0, int3.zero.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_constructor() { int3 a = new int3(1, 2, 3); @@ -32,7 +32,7 @@ public static void int3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_scalar_constructor() { int3 a = new int3(17); @@ -41,7 +41,7 @@ public static void int3_scalar_constructor() TestUtils.AreEqual(17, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_static_constructor() { int3 a = int3(1, 2, 3); @@ -50,7 +50,7 @@ public static void int3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_static_scalar_constructor() { int3 a = int3(17); @@ -59,7 +59,7 @@ public static void int3_static_scalar_constructor() TestUtils.AreEqual(17, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_equal_wide_wide() { int3 a0 = int3(2105871082, 35218899, 1550755093); @@ -83,7 +83,7 @@ public static void int3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_equal_wide_scalar() { int3 a0 = int3(437822262, 2020661134, 541786900); @@ -107,7 +107,7 @@ public static void int3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -131,7 +131,7 @@ public static void int3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_not_equal_wide_wide() { int3 a0 = int3(1977284100, 1293292704, 1547283851); @@ -155,7 +155,7 @@ public static void int3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_not_equal_wide_scalar() { int3 a0 = int3(1038269360, 1427812625, 103361237); @@ -179,7 +179,7 @@ public static void int3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -203,7 +203,7 @@ public static void int3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_less_wide_wide() { int3 a0 = int3(1486550609, 1779244308, 1602148045); @@ -227,7 +227,7 @@ public static void int3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_less_wide_scalar() { int3 a0 = int3(796797557, 670113454, 933579492); @@ -251,7 +251,7 @@ public static void int3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_less_scalar_wide() { int a0 = (186400299); @@ -275,7 +275,7 @@ public static void int3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_greater_wide_wide() { int3 a0 = int3(2087717754, 1725569452, 1298066182); @@ -299,7 +299,7 @@ public static void int3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_greater_wide_scalar() { int3 a0 = int3(1208626274, 239697208, 1979453345); @@ -323,7 +323,7 @@ public static void int3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -347,7 +347,7 @@ public static void int3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_less_equal_wide_wide() { int3 a0 = int3(154092149, 1515170149, 1083970332); @@ -371,7 +371,7 @@ public static void int3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_less_equal_wide_scalar() { int3 a0 = int3(1479531977, 1427983411, 415250630); @@ -395,7 +395,7 @@ public static void int3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -419,7 +419,7 @@ public static void int3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_greater_equal_wide_wide() { int3 a0 = int3(8538378, 2131749726, 265427108); @@ -443,7 +443,7 @@ public static void int3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_greater_equal_wide_scalar() { int3 a0 = int3(2049236663, 182691143, 634973382); @@ -467,7 +467,7 @@ public static void int3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -491,7 +491,7 @@ public static void int3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_add_wide_wide() { int3 a0 = int3(2135171378, 21433296, 1954723494); @@ -515,7 +515,7 @@ public static void int3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_add_wide_scalar() { int3 a0 = int3(665815972, 1783729250, 1591678394); @@ -539,7 +539,7 @@ public static void int3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_add_scalar_wide() { int a0 = (359966320); @@ -563,7 +563,7 @@ public static void int3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_sub_wide_wide() { int3 a0 = int3(1410318491, 1097280168, 1827039044); @@ -587,7 +587,7 @@ public static void int3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_sub_wide_scalar() { int3 a0 = int3(1508669340, 1594795463, 266707545); @@ -611,7 +611,7 @@ public static void int3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -635,7 +635,7 @@ public static void int3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_mul_wide_wide() { int3 a0 = int3(61417577, 219585476, 1362520891); @@ -659,7 +659,7 @@ public static void int3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_mul_wide_scalar() { int3 a0 = int3(871746615, 492532311, 570557670); @@ -683,7 +683,7 @@ public static void int3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -707,7 +707,7 @@ public static void int3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_div_wide_wide() { int3 a0 = int3(333171510, 858154903, 1181365836); @@ -731,7 +731,7 @@ public static void int3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_div_wide_scalar() { int3 a0 = int3(1433072926, 1073958635, 1195142312); @@ -755,7 +755,7 @@ public static void int3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_div_scalar_wide() { int a0 = (519165704); @@ -779,7 +779,7 @@ public static void int3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_mod_wide_wide() { int3 a0 = int3(258342924, 1454754891, 723352342); @@ -803,7 +803,7 @@ public static void int3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_mod_wide_scalar() { int3 a0 = int3(560988938, 629524514, 767711194); @@ -827,7 +827,7 @@ public static void int3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -851,7 +851,7 @@ public static void int3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_plus() { int3 a0 = int3(195392567, 222719748, 1002351013); @@ -871,7 +871,7 @@ public static void int3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_neg() { int3 a0 = int3(1385088677, 94114564, 1350664872); @@ -891,7 +891,7 @@ public static void int3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_prefix_inc() { int3 a0 = int3(780471723, 954741756, 272723451); @@ -911,7 +911,7 @@ public static void int3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_postfix_inc() { int3 a0 = int3(241865086, 2145821641, 1596166022); @@ -931,7 +931,7 @@ public static void int3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_prefix_dec() { int3 a0 = int3(1331961415, 1612382200, 1401591249); @@ -951,7 +951,7 @@ public static void int3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_postfix_dec() { int3 a0 = int3(1870005937, 1708534798, 704493460); @@ -971,7 +971,7 @@ public static void int3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_and_wide_wide() { int3 a0 = int3(1055241304, 859321394, 1088358961); @@ -995,7 +995,7 @@ public static void int3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_and_wide_scalar() { int3 a0 = int3(1513158868, 284695609, 734595037); @@ -1019,7 +1019,7 @@ public static void int3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1043,7 +1043,7 @@ public static void int3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_or_wide_wide() { int3 a0 = int3(1920951869, 1750772852, 1420019191); @@ -1067,7 +1067,7 @@ public static void int3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_or_wide_scalar() { int3 a0 = int3(1295304853, 1307252624, 350194630); @@ -1091,7 +1091,7 @@ public static void int3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1115,7 +1115,7 @@ public static void int3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_xor_wide_wide() { int3 a0 = int3(1843655608, 362425681, 640805534); @@ -1139,7 +1139,7 @@ public static void int3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_xor_wide_scalar() { int3 a0 = int3(169345668, 176087064, 2084362901); @@ -1163,7 +1163,7 @@ public static void int3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1187,7 +1187,7 @@ public static void int3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_left_shift() { int3 a0 = int3(1129100049, 829482269, 1571297368); @@ -1211,7 +1211,7 @@ public static void int3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_right_shift() { int3 a0 = int3(809126085, 908563670, 763568837); @@ -1235,7 +1235,7 @@ public static void int3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_operator_bitwise_not() { int3 a0 = int3(111796841, 603562399, 745091931); @@ -1255,7 +1255,7 @@ public static void int3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_shuffle_result_1() { int3 a = int3(0, 1, 2); @@ -1269,7 +1269,7 @@ public static void int3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_shuffle_result_2() { int3 a = int3(0, 1, 2); @@ -1293,7 +1293,7 @@ public static void int3_shuffle_result_2() TestUtils.AreEqual(int2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_shuffle_result_3() { int3 a = int3(0, 1, 2); @@ -1317,7 +1317,7 @@ public static void int3_shuffle_result_3() TestUtils.AreEqual(int3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_shuffle_result_4() { int3 a = int3(0, 1, 2); diff --git a/src/Tests/Tests/Shared/TestInt3x2.gen.cs b/src/Tests/Tests/Shared/TestInt3x2.gen.cs index 769f2d00..db159df9 100644 --- a/src/Tests/Tests/Shared/TestInt3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_zero() { TestUtils.AreEqual(0, int3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void int3x2_zero() TestUtils.AreEqual(0, int3x2.zero.c1.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_equal_wide_wide() { int3x2 a0 = int3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void int3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_equal_wide_scalar() { int3x2 a0 = int3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void int3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -98,7 +98,7 @@ public static void int3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_not_equal_wide_wide() { int3x2 a0 = int3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void int3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_not_equal_wide_scalar() { int3x2 a0 = int3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void int3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -170,7 +170,7 @@ public static void int3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_less_wide_wide() { int3x2 a0 = int3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void int3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_less_wide_scalar() { int3x2 a0 = int3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void int3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_less_scalar_wide() { int a0 = (186400299); @@ -242,7 +242,7 @@ public static void int3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_greater_wide_wide() { int3x2 a0 = int3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void int3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_greater_wide_scalar() { int3x2 a0 = int3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void int3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -314,7 +314,7 @@ public static void int3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_less_equal_wide_wide() { int3x2 a0 = int3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void int3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_less_equal_wide_scalar() { int3x2 a0 = int3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void int3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -386,7 +386,7 @@ public static void int3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_greater_equal_wide_wide() { int3x2 a0 = int3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void int3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_greater_equal_wide_scalar() { int3x2 a0 = int3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void int3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -458,7 +458,7 @@ public static void int3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_add_wide_wide() { int3x2 a0 = int3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void int3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_add_wide_scalar() { int3x2 a0 = int3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void int3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_add_scalar_wide() { int a0 = (359966320); @@ -530,7 +530,7 @@ public static void int3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_sub_wide_wide() { int3x2 a0 = int3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void int3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_sub_wide_scalar() { int3x2 a0 = int3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void int3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -602,7 +602,7 @@ public static void int3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_mul_wide_wide() { int3x2 a0 = int3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void int3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_mul_wide_scalar() { int3x2 a0 = int3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void int3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -674,7 +674,7 @@ public static void int3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_div_wide_wide() { int3x2 a0 = int3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void int3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_div_wide_scalar() { int3x2 a0 = int3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void int3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_div_scalar_wide() { int a0 = (519165704); @@ -746,7 +746,7 @@ public static void int3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_mod_wide_wide() { int3x2 a0 = int3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void int3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_mod_wide_scalar() { int3x2 a0 = int3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void int3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -818,7 +818,7 @@ public static void int3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_plus() { int3x2 a0 = int3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void int3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_neg() { int3x2 a0 = int3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void int3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_prefix_inc() { int3x2 a0 = int3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void int3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_postfix_inc() { int3x2 a0 = int3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void int3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_prefix_dec() { int3x2 a0 = int3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void int3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_postfix_dec() { int3x2 a0 = int3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void int3x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_and_wide_wide() { int3x2 a0 = int3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void int3x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_and_wide_scalar() { int3x2 a0 = int3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void int3x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void int3x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_or_wide_wide() { int3x2 a0 = int3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void int3x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_or_wide_scalar() { int3x2 a0 = int3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void int3x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void int3x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_xor_wide_wide() { int3x2 a0 = int3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void int3x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_xor_wide_scalar() { int3x2 a0 = int3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void int3x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void int3x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_left_shift() { int3x2 a0 = int3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void int3x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_right_shift() { int3x2 a0 = int3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void int3x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x2_operator_bitwise_not() { int3x2 a0 = int3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); diff --git a/src/Tests/Tests/Shared/TestInt3x3.gen.cs b/src/Tests/Tests/Shared/TestInt3x3.gen.cs index c2a99c4f..5d82264a 100644 --- a/src/Tests/Tests/Shared/TestInt3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_zero() { TestUtils.AreEqual(0, int3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void int3x3_zero() TestUtils.AreEqual(0, int3x3.zero.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_identity() { TestUtils.AreEqual(1, int3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void int3x3_identity() TestUtils.AreEqual(1, int3x3.identity.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_equal_wide_wide() { int3x3 a0 = int3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367); @@ -67,7 +67,7 @@ public static void int3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_equal_wide_scalar() { int3x3 a0 = int3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998); @@ -91,7 +91,7 @@ public static void int3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -115,7 +115,7 @@ public static void int3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_not_equal_wide_wide() { int3x3 a0 = int3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678); @@ -139,7 +139,7 @@ public static void int3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_not_equal_wide_scalar() { int3x3 a0 = int3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423); @@ -163,7 +163,7 @@ public static void int3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -187,7 +187,7 @@ public static void int3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_less_wide_wide() { int3x3 a0 = int3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312); @@ -211,7 +211,7 @@ public static void int3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_less_wide_scalar() { int3x3 a0 = int3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597); @@ -235,7 +235,7 @@ public static void int3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_less_scalar_wide() { int a0 = (186400299); @@ -259,7 +259,7 @@ public static void int3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_greater_wide_wide() { int3x3 a0 = int3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133); @@ -283,7 +283,7 @@ public static void int3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_greater_wide_scalar() { int3x3 a0 = int3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855); @@ -307,7 +307,7 @@ public static void int3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -331,7 +331,7 @@ public static void int3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_less_equal_wide_wide() { int3x3 a0 = int3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541); @@ -355,7 +355,7 @@ public static void int3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_less_equal_wide_scalar() { int3x3 a0 = int3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375); @@ -379,7 +379,7 @@ public static void int3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -403,7 +403,7 @@ public static void int3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_greater_equal_wide_wide() { int3x3 a0 = int3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826); @@ -427,7 +427,7 @@ public static void int3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_greater_equal_wide_scalar() { int3x3 a0 = int3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669); @@ -451,7 +451,7 @@ public static void int3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -475,7 +475,7 @@ public static void int3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_add_wide_wide() { int3x3 a0 = int3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600); @@ -499,7 +499,7 @@ public static void int3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_add_wide_scalar() { int3x3 a0 = int3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008); @@ -523,7 +523,7 @@ public static void int3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_add_scalar_wide() { int a0 = (359966320); @@ -547,7 +547,7 @@ public static void int3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_sub_wide_wide() { int3x3 a0 = int3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315); @@ -571,7 +571,7 @@ public static void int3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_sub_wide_scalar() { int3x3 a0 = int3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113); @@ -595,7 +595,7 @@ public static void int3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -619,7 +619,7 @@ public static void int3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_mul_wide_wide() { int3x3 a0 = int3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583); @@ -643,7 +643,7 @@ public static void int3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_mul_wide_scalar() { int3x3 a0 = int3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059); @@ -667,7 +667,7 @@ public static void int3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -691,7 +691,7 @@ public static void int3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_div_wide_wide() { int3x3 a0 = int3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195); @@ -715,7 +715,7 @@ public static void int3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_div_wide_scalar() { int3x3 a0 = int3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136); @@ -739,7 +739,7 @@ public static void int3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_div_scalar_wide() { int a0 = (519165704); @@ -763,7 +763,7 @@ public static void int3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_mod_wide_wide() { int3x3 a0 = int3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101); @@ -787,7 +787,7 @@ public static void int3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_mod_wide_scalar() { int3x3 a0 = int3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144); @@ -811,7 +811,7 @@ public static void int3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -835,7 +835,7 @@ public static void int3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_plus() { int3x3 a0 = int3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671); @@ -855,7 +855,7 @@ public static void int3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_neg() { int3x3 a0 = int3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525); @@ -875,7 +875,7 @@ public static void int3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_prefix_inc() { int3x3 a0 = int3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994); @@ -895,7 +895,7 @@ public static void int3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_postfix_inc() { int3x3 a0 = int3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247); @@ -915,7 +915,7 @@ public static void int3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_prefix_dec() { int3x3 a0 = int3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745); @@ -935,7 +935,7 @@ public static void int3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_postfix_dec() { int3x3 a0 = int3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889); @@ -955,7 +955,7 @@ public static void int3x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_and_wide_wide() { int3x3 a0 = int3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656); @@ -979,7 +979,7 @@ public static void int3x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_and_wide_scalar() { int3x3 a0 = int3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263); @@ -1003,7 +1003,7 @@ public static void int3x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1027,7 +1027,7 @@ public static void int3x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_or_wide_wide() { int3x3 a0 = int3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869); @@ -1051,7 +1051,7 @@ public static void int3x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_or_wide_scalar() { int3x3 a0 = int3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307); @@ -1075,7 +1075,7 @@ public static void int3x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1099,7 +1099,7 @@ public static void int3x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_xor_wide_wide() { int3x3 a0 = int3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251); @@ -1123,7 +1123,7 @@ public static void int3x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_xor_wide_scalar() { int3x3 a0 = int3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873); @@ -1147,7 +1147,7 @@ public static void int3x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1171,7 +1171,7 @@ public static void int3x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_left_shift() { int3x3 a0 = int3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727); @@ -1195,7 +1195,7 @@ public static void int3x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_right_shift() { int3x3 a0 = int3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393); @@ -1219,7 +1219,7 @@ public static void int3x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x3_operator_bitwise_not() { int3x3 a0 = int3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628); diff --git a/src/Tests/Tests/Shared/TestInt3x4.gen.cs b/src/Tests/Tests/Shared/TestInt3x4.gen.cs index 449377a8..f9b43392 100644 --- a/src/Tests/Tests/Shared/TestInt3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt3x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_zero() { TestUtils.AreEqual(0, int3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void int3x4_zero() TestUtils.AreEqual(0, int3x4.zero.c3.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_equal_wide_wide() { int3x4 a0 = int3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void int3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_equal_wide_scalar() { int3x4 a0 = int3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void int3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -104,7 +104,7 @@ public static void int3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_not_equal_wide_wide() { int3x4 a0 = int3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void int3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_not_equal_wide_scalar() { int3x4 a0 = int3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void int3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -176,7 +176,7 @@ public static void int3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_less_wide_wide() { int3x4 a0 = int3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void int3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_less_wide_scalar() { int3x4 a0 = int3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void int3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_less_scalar_wide() { int a0 = (186400299); @@ -248,7 +248,7 @@ public static void int3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_greater_wide_wide() { int3x4 a0 = int3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void int3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_greater_wide_scalar() { int3x4 a0 = int3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void int3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -320,7 +320,7 @@ public static void int3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_less_equal_wide_wide() { int3x4 a0 = int3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void int3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_less_equal_wide_scalar() { int3x4 a0 = int3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void int3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -392,7 +392,7 @@ public static void int3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_greater_equal_wide_wide() { int3x4 a0 = int3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void int3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_greater_equal_wide_scalar() { int3x4 a0 = int3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void int3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -464,7 +464,7 @@ public static void int3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_add_wide_wide() { int3x4 a0 = int3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void int3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_add_wide_scalar() { int3x4 a0 = int3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void int3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_add_scalar_wide() { int a0 = (359966320); @@ -536,7 +536,7 @@ public static void int3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_sub_wide_wide() { int3x4 a0 = int3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void int3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_sub_wide_scalar() { int3x4 a0 = int3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void int3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -608,7 +608,7 @@ public static void int3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_mul_wide_wide() { int3x4 a0 = int3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void int3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_mul_wide_scalar() { int3x4 a0 = int3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void int3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -680,7 +680,7 @@ public static void int3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_div_wide_wide() { int3x4 a0 = int3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void int3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_div_wide_scalar() { int3x4 a0 = int3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void int3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_div_scalar_wide() { int a0 = (519165704); @@ -752,7 +752,7 @@ public static void int3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_mod_wide_wide() { int3x4 a0 = int3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void int3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_mod_wide_scalar() { int3x4 a0 = int3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void int3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -824,7 +824,7 @@ public static void int3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_plus() { int3x4 a0 = int3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void int3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_neg() { int3x4 a0 = int3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void int3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_prefix_inc() { int3x4 a0 = int3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void int3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_postfix_inc() { int3x4 a0 = int3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void int3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_prefix_dec() { int3x4 a0 = int3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void int3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_postfix_dec() { int3x4 a0 = int3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void int3x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_and_wide_wide() { int3x4 a0 = int3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void int3x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_and_wide_scalar() { int3x4 a0 = int3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void int3x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void int3x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_or_wide_wide() { int3x4 a0 = int3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void int3x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_or_wide_scalar() { int3x4 a0 = int3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void int3x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void int3x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_xor_wide_wide() { int3x4 a0 = int3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void int3x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_xor_wide_scalar() { int3x4 a0 = int3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void int3x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void int3x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_left_shift() { int3x4 a0 = int3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void int3x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_right_shift() { int3x4 a0 = int3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void int3x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3x4_operator_bitwise_not() { int3x4 a0 = int3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); diff --git a/src/Tests/Tests/Shared/TestInt4.gen.cs b/src/Tests/Tests/Shared/TestInt4.gen.cs index 5aaff365..3c712b61 100644 --- a/src/Tests/Tests/Shared/TestInt4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_zero() { TestUtils.AreEqual(0, int4.zero.x); @@ -24,7 +24,7 @@ public static void int4_zero() TestUtils.AreEqual(0, int4.zero.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_constructor() { int4 a = new int4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void int4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_scalar_constructor() { int4 a = new int4(17); @@ -44,7 +44,7 @@ public static void int4_scalar_constructor() TestUtils.AreEqual(17, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_static_constructor() { int4 a = int4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void int4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_static_scalar_constructor() { int4 a = int4(17); @@ -64,7 +64,7 @@ public static void int4_static_scalar_constructor() TestUtils.AreEqual(17, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_equal_wide_wide() { int4 a0 = int4(2105871082, 35218899, 1550755093, 764676020); @@ -88,7 +88,7 @@ public static void int4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_equal_wide_scalar() { int4 a0 = int4(437822262, 2020661134, 541786900, 853113810); @@ -112,7 +112,7 @@ public static void int4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -136,7 +136,7 @@ public static void int4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_not_equal_wide_wide() { int4 a0 = int4(1977284100, 1293292704, 1547283851, 422428953); @@ -160,7 +160,7 @@ public static void int4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_not_equal_wide_scalar() { int4 a0 = int4(1038269360, 1427812625, 103361237, 1347017023); @@ -184,7 +184,7 @@ public static void int4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -208,7 +208,7 @@ public static void int4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_less_wide_wide() { int4 a0 = int4(1486550609, 1779244308, 1602148045, 1614085440); @@ -232,7 +232,7 @@ public static void int4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_less_wide_scalar() { int4 a0 = int4(796797557, 670113454, 933579492, 278884514); @@ -256,7 +256,7 @@ public static void int4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_less_scalar_wide() { int a0 = (186400299); @@ -280,7 +280,7 @@ public static void int4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_greater_wide_wide() { int4 a0 = int4(2087717754, 1725569452, 1298066182, 1693943616); @@ -304,7 +304,7 @@ public static void int4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_greater_wide_scalar() { int4 a0 = int4(1208626274, 239697208, 1979453345, 1253474001); @@ -328,7 +328,7 @@ public static void int4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -352,7 +352,7 @@ public static void int4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_less_equal_wide_wide() { int4 a0 = int4(154092149, 1515170149, 1083970332, 785807178); @@ -376,7 +376,7 @@ public static void int4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_less_equal_wide_scalar() { int4 a0 = int4(1479531977, 1427983411, 415250630, 1245345407); @@ -400,7 +400,7 @@ public static void int4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -424,7 +424,7 @@ public static void int4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_greater_equal_wide_wide() { int4 a0 = int4(8538378, 2131749726, 265427108, 523609761); @@ -448,7 +448,7 @@ public static void int4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_greater_equal_wide_scalar() { int4 a0 = int4(2049236663, 182691143, 634973382, 1197012109); @@ -472,7 +472,7 @@ public static void int4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -496,7 +496,7 @@ public static void int4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_add_wide_wide() { int4 a0 = int4(2135171378, 21433296, 1954723494, 683604307); @@ -520,7 +520,7 @@ public static void int4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_add_wide_scalar() { int4 a0 = int4(665815972, 1783729250, 1591678394, 1284528538); @@ -544,7 +544,7 @@ public static void int4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_add_scalar_wide() { int a0 = (359966320); @@ -568,7 +568,7 @@ public static void int4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_sub_wide_wide() { int4 a0 = int4(1410318491, 1097280168, 1827039044, 28881338); @@ -592,7 +592,7 @@ public static void int4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_sub_wide_scalar() { int4 a0 = int4(1508669340, 1594795463, 266707545, 643102647); @@ -616,7 +616,7 @@ public static void int4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -640,7 +640,7 @@ public static void int4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_mul_wide_wide() { int4 a0 = int4(61417577, 219585476, 1362520891, 1511084277); @@ -664,7 +664,7 @@ public static void int4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_mul_wide_scalar() { int4 a0 = int4(871746615, 492532311, 570557670, 2142306629); @@ -688,7 +688,7 @@ public static void int4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -712,7 +712,7 @@ public static void int4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_div_wide_wide() { int4 a0 = int4(333171510, 858154903, 1181365836, 671357749); @@ -736,7 +736,7 @@ public static void int4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_div_wide_scalar() { int4 a0 = int4(1433072926, 1073958635, 1195142312, 536596719); @@ -760,7 +760,7 @@ public static void int4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_div_scalar_wide() { int a0 = (519165704); @@ -784,7 +784,7 @@ public static void int4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_mod_wide_wide() { int4 a0 = int4(258342924, 1454754891, 723352342, 1981431473); @@ -808,7 +808,7 @@ public static void int4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_mod_wide_scalar() { int4 a0 = int4(560988938, 629524514, 767711194, 434281967); @@ -832,7 +832,7 @@ public static void int4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -856,7 +856,7 @@ public static void int4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_plus() { int4 a0 = int4(195392567, 222719748, 1002351013, 1570765263); @@ -876,7 +876,7 @@ public static void int4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_neg() { int4 a0 = int4(1385088677, 94114564, 1350664872, 1458616659); @@ -896,7 +896,7 @@ public static void int4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_prefix_inc() { int4 a0 = int4(780471723, 954741756, 272723451, 2142862245); @@ -916,7 +916,7 @@ public static void int4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_postfix_inc() { int4 a0 = int4(241865086, 2145821641, 1596166022, 803592338); @@ -936,7 +936,7 @@ public static void int4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_prefix_dec() { int4 a0 = int4(1331961415, 1612382200, 1401591249, 2042075388); @@ -956,7 +956,7 @@ public static void int4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_postfix_dec() { int4 a0 = int4(1870005937, 1708534798, 704493460, 462940703); @@ -976,7 +976,7 @@ public static void int4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_and_wide_wide() { int4 a0 = int4(1055241304, 859321394, 1088358961, 2090949513); @@ -1000,7 +1000,7 @@ public static void int4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_and_wide_scalar() { int4 a0 = int4(1513158868, 284695609, 734595037, 1566510707); @@ -1024,7 +1024,7 @@ public static void int4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1048,7 +1048,7 @@ public static void int4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_or_wide_wide() { int4 a0 = int4(1920951869, 1750772852, 1420019191, 732977093); @@ -1072,7 +1072,7 @@ public static void int4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_or_wide_scalar() { int4 a0 = int4(1295304853, 1307252624, 350194630, 1128063578); @@ -1096,7 +1096,7 @@ public static void int4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1120,7 +1120,7 @@ public static void int4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_xor_wide_wide() { int4 a0 = int4(1843655608, 362425681, 640805534, 1342040268); @@ -1144,7 +1144,7 @@ public static void int4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_xor_wide_scalar() { int4 a0 = int4(169345668, 176087064, 2084362901, 1663924004); @@ -1168,7 +1168,7 @@ public static void int4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1192,7 +1192,7 @@ public static void int4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_left_shift() { int4 a0 = int4(1129100049, 829482269, 1571297368, 443753193); @@ -1216,7 +1216,7 @@ public static void int4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_right_shift() { int4 a0 = int4(809126085, 908563670, 763568837, 1986717290); @@ -1240,7 +1240,7 @@ public static void int4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_operator_bitwise_not() { int4 a0 = int4(111796841, 603562399, 745091931, 853183268); @@ -1260,7 +1260,7 @@ public static void int4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_shuffle_result_1() { int4 a = int4(0, 1, 2, 3); @@ -1276,7 +1276,7 @@ public static void int4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_shuffle_result_2() { int4 a = int4(0, 1, 2, 3); @@ -1300,7 +1300,7 @@ public static void int4_shuffle_result_2() TestUtils.AreEqual(int2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_shuffle_result_3() { int4 a = int4(0, 1, 2, 3); @@ -1324,7 +1324,7 @@ public static void int4_shuffle_result_3() TestUtils.AreEqual(int3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_shuffle_result_4() { int4 a = int4(0, 1, 2, 3); diff --git a/src/Tests/Tests/Shared/TestInt4x2.gen.cs b/src/Tests/Tests/Shared/TestInt4x2.gen.cs index c4528cd7..8eaa8828 100644 --- a/src/Tests/Tests/Shared/TestInt4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_zero() { TestUtils.AreEqual(0, int4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void int4x2_zero() TestUtils.AreEqual(0, int4x2.zero.c1.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_equal_wide_wide() { int4x2 a0 = int4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void int4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_equal_wide_scalar() { int4x2 a0 = int4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void int4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_equal_scalar_wide() { int a0 = (542329200); @@ -100,7 +100,7 @@ public static void int4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_not_equal_wide_wide() { int4x2 a0 = int4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void int4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_not_equal_wide_scalar() { int4x2 a0 = int4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void int4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -172,7 +172,7 @@ public static void int4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_less_wide_wide() { int4x2 a0 = int4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void int4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_less_wide_scalar() { int4x2 a0 = int4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void int4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_less_scalar_wide() { int a0 = (186400299); @@ -244,7 +244,7 @@ public static void int4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_greater_wide_wide() { int4x2 a0 = int4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void int4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_greater_wide_scalar() { int4x2 a0 = int4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void int4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_greater_scalar_wide() { int a0 = (480938827); @@ -316,7 +316,7 @@ public static void int4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_less_equal_wide_wide() { int4x2 a0 = int4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void int4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_less_equal_wide_scalar() { int4x2 a0 = int4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void int4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -388,7 +388,7 @@ public static void int4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_greater_equal_wide_wide() { int4x2 a0 = int4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void int4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_greater_equal_wide_scalar() { int4x2 a0 = int4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void int4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -460,7 +460,7 @@ public static void int4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_add_wide_wide() { int4x2 a0 = int4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void int4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_add_wide_scalar() { int4x2 a0 = int4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void int4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_add_scalar_wide() { int a0 = (359966320); @@ -532,7 +532,7 @@ public static void int4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_sub_wide_wide() { int4x2 a0 = int4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void int4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_sub_wide_scalar() { int4x2 a0 = int4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void int4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_sub_scalar_wide() { int a0 = (893369501); @@ -604,7 +604,7 @@ public static void int4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_mul_wide_wide() { int4x2 a0 = int4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void int4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_mul_wide_scalar() { int4x2 a0 = int4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void int4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -676,7 +676,7 @@ public static void int4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_div_wide_wide() { int4x2 a0 = int4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void int4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_div_wide_scalar() { int4x2 a0 = int4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void int4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_div_scalar_wide() { int a0 = (519165704); @@ -748,7 +748,7 @@ public static void int4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_mod_wide_wide() { int4x2 a0 = int4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void int4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_mod_wide_scalar() { int4x2 a0 = int4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void int4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_mod_scalar_wide() { int a0 = (933347930); @@ -820,7 +820,7 @@ public static void int4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_plus() { int4x2 a0 = int4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void int4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_neg() { int4x2 a0 = int4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void int4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_prefix_inc() { int4x2 a0 = int4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void int4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_postfix_inc() { int4x2 a0 = int4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void int4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_prefix_dec() { int4x2 a0 = int4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void int4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_postfix_dec() { int4x2 a0 = int4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void int4x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_and_wide_wide() { int4x2 a0 = int4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void int4x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_and_wide_scalar() { int4x2 a0 = int4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void int4x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void int4x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_or_wide_wide() { int4x2 a0 = int4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void int4x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_or_wide_scalar() { int4x2 a0 = int4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void int4x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void int4x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_xor_wide_wide() { int4x2 a0 = int4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void int4x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_xor_wide_scalar() { int4x2 a0 = int4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void int4x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void int4x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_left_shift() { int4x2 a0 = int4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void int4x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_right_shift() { int4x2 a0 = int4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void int4x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x2_operator_bitwise_not() { int4x2 a0 = int4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); diff --git a/src/Tests/Tests/Shared/TestInt4x3.gen.cs b/src/Tests/Tests/Shared/TestInt4x3.gen.cs index fec49565..c8662413 100644 --- a/src/Tests/Tests/Shared/TestInt4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_zero() { TestUtils.AreEqual(0, int4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void int4x3_zero() TestUtils.AreEqual(0, int4x3.zero.c2.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_equal_wide_wide() { int4x3 a0 = int4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void int4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_equal_wide_scalar() { int4x3 a0 = int4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void int4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_equal_scalar_wide() { int a0 = (542329200); @@ -104,7 +104,7 @@ public static void int4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_not_equal_wide_wide() { int4x3 a0 = int4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void int4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_not_equal_wide_scalar() { int4x3 a0 = int4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void int4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -176,7 +176,7 @@ public static void int4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_less_wide_wide() { int4x3 a0 = int4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void int4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_less_wide_scalar() { int4x3 a0 = int4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void int4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_less_scalar_wide() { int a0 = (186400299); @@ -248,7 +248,7 @@ public static void int4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_greater_wide_wide() { int4x3 a0 = int4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void int4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_greater_wide_scalar() { int4x3 a0 = int4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void int4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_greater_scalar_wide() { int a0 = (480938827); @@ -320,7 +320,7 @@ public static void int4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_less_equal_wide_wide() { int4x3 a0 = int4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void int4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_less_equal_wide_scalar() { int4x3 a0 = int4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void int4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -392,7 +392,7 @@ public static void int4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_greater_equal_wide_wide() { int4x3 a0 = int4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void int4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_greater_equal_wide_scalar() { int4x3 a0 = int4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void int4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -464,7 +464,7 @@ public static void int4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_add_wide_wide() { int4x3 a0 = int4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void int4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_add_wide_scalar() { int4x3 a0 = int4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void int4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_add_scalar_wide() { int a0 = (359966320); @@ -536,7 +536,7 @@ public static void int4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_sub_wide_wide() { int4x3 a0 = int4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void int4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_sub_wide_scalar() { int4x3 a0 = int4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void int4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_sub_scalar_wide() { int a0 = (893369501); @@ -608,7 +608,7 @@ public static void int4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_mul_wide_wide() { int4x3 a0 = int4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void int4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_mul_wide_scalar() { int4x3 a0 = int4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void int4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -680,7 +680,7 @@ public static void int4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_div_wide_wide() { int4x3 a0 = int4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void int4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_div_wide_scalar() { int4x3 a0 = int4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void int4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_div_scalar_wide() { int a0 = (519165704); @@ -752,7 +752,7 @@ public static void int4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_mod_wide_wide() { int4x3 a0 = int4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void int4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_mod_wide_scalar() { int4x3 a0 = int4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void int4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_mod_scalar_wide() { int a0 = (933347930); @@ -824,7 +824,7 @@ public static void int4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_plus() { int4x3 a0 = int4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void int4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_neg() { int4x3 a0 = int4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void int4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_prefix_inc() { int4x3 a0 = int4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void int4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_postfix_inc() { int4x3 a0 = int4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void int4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_prefix_dec() { int4x3 a0 = int4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void int4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_postfix_dec() { int4x3 a0 = int4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void int4x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_and_wide_wide() { int4x3 a0 = int4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void int4x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_and_wide_scalar() { int4x3 a0 = int4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void int4x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void int4x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_or_wide_wide() { int4x3 a0 = int4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void int4x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_or_wide_scalar() { int4x3 a0 = int4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void int4x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void int4x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_xor_wide_wide() { int4x3 a0 = int4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void int4x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_xor_wide_scalar() { int4x3 a0 = int4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void int4x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void int4x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_left_shift() { int4x3 a0 = int4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void int4x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_right_shift() { int4x3 a0 = int4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void int4x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x3_operator_bitwise_not() { int4x3 a0 = int4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); diff --git a/src/Tests/Tests/Shared/TestInt4x4.gen.cs b/src/Tests/Tests/Shared/TestInt4x4.gen.cs index 81786fb7..408529a2 100644 --- a/src/Tests/Tests/Shared/TestInt4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestInt4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestInt4x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_zero() { TestUtils.AreEqual(0, int4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void int4x4_zero() TestUtils.AreEqual(0, int4x4.zero.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_identity() { TestUtils.AreEqual(1, int4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void int4x4_identity() TestUtils.AreEqual(1, int4x4.identity.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_equal_wide_wide() { int4x4 a0 = int4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805); @@ -81,7 +81,7 @@ public static void int4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_equal_wide_scalar() { int4x4 a0 = int4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611); @@ -105,7 +105,7 @@ public static void int4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_equal_scalar_wide() { int a0 = (542329200); @@ -129,7 +129,7 @@ public static void int4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_not_equal_wide_wide() { int4x4 a0 = int4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126); @@ -153,7 +153,7 @@ public static void int4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_not_equal_wide_scalar() { int4x4 a0 = int4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260); @@ -177,7 +177,7 @@ public static void int4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_not_equal_scalar_wide() { int a0 = (1652127596); @@ -201,7 +201,7 @@ public static void int4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_less_wide_wide() { int4x4 a0 = int4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012); @@ -225,7 +225,7 @@ public static void int4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_less_wide_scalar() { int4x4 a0 = int4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157); @@ -249,7 +249,7 @@ public static void int4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_less_scalar_wide() { int a0 = (186400299); @@ -273,7 +273,7 @@ public static void int4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_greater_wide_wide() { int4x4 a0 = int4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063); @@ -297,7 +297,7 @@ public static void int4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_greater_wide_scalar() { int4x4 a0 = int4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537); @@ -321,7 +321,7 @@ public static void int4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_greater_scalar_wide() { int a0 = (480938827); @@ -345,7 +345,7 @@ public static void int4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_less_equal_wide_wide() { int4x4 a0 = int4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458); @@ -369,7 +369,7 @@ public static void int4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_less_equal_wide_scalar() { int4x4 a0 = int4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699); @@ -393,7 +393,7 @@ public static void int4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_less_equal_scalar_wide() { int a0 = (1899193992); @@ -417,7 +417,7 @@ public static void int4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_greater_equal_wide_wide() { int4x4 a0 = int4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690); @@ -441,7 +441,7 @@ public static void int4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_greater_equal_wide_scalar() { int4x4 a0 = int4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144); @@ -465,7 +465,7 @@ public static void int4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_greater_equal_scalar_wide() { int a0 = (1859811087); @@ -489,7 +489,7 @@ public static void int4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_add_wide_wide() { int4x4 a0 = int4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699); @@ -513,7 +513,7 @@ public static void int4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_add_wide_scalar() { int4x4 a0 = int4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741); @@ -537,7 +537,7 @@ public static void int4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_add_scalar_wide() { int a0 = (359966320); @@ -561,7 +561,7 @@ public static void int4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_sub_wide_wide() { int4x4 a0 = int4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464); @@ -585,7 +585,7 @@ public static void int4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_sub_wide_scalar() { int4x4 a0 = int4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902); @@ -609,7 +609,7 @@ public static void int4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_sub_scalar_wide() { int a0 = (893369501); @@ -633,7 +633,7 @@ public static void int4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_mul_wide_wide() { int4x4 a0 = int4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174); @@ -657,7 +657,7 @@ public static void int4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_mul_wide_scalar() { int4x4 a0 = int4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135); @@ -681,7 +681,7 @@ public static void int4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_mul_scalar_wide() { int a0 = (1152242766); @@ -705,7 +705,7 @@ public static void int4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_div_wide_wide() { int4x4 a0 = int4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781); @@ -729,7 +729,7 @@ public static void int4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_div_wide_scalar() { int4x4 a0 = int4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263); @@ -753,7 +753,7 @@ public static void int4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_div_scalar_wide() { int a0 = (519165704); @@ -777,7 +777,7 @@ public static void int4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_mod_wide_wide() { int4x4 a0 = int4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943); @@ -801,7 +801,7 @@ public static void int4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_mod_wide_scalar() { int4x4 a0 = int4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114); @@ -825,7 +825,7 @@ public static void int4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_mod_scalar_wide() { int a0 = (933347930); @@ -849,7 +849,7 @@ public static void int4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_plus() { int4x4 a0 = int4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903); @@ -869,7 +869,7 @@ public static void int4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_neg() { int4x4 a0 = int4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416); @@ -889,7 +889,7 @@ public static void int4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_prefix_inc() { int4x4 a0 = int4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230); @@ -909,7 +909,7 @@ public static void int4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_postfix_inc() { int4x4 a0 = int4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180); @@ -929,7 +929,7 @@ public static void int4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_prefix_dec() { int4x4 a0 = int4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619); @@ -949,7 +949,7 @@ public static void int4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_postfix_dec() { int4x4 a0 = int4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301); @@ -969,7 +969,7 @@ public static void int4x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_and_wide_wide() { int4x4 a0 = int4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376); @@ -993,7 +993,7 @@ public static void int4x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_and_wide_scalar() { int4x4 a0 = int4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952); @@ -1017,7 +1017,7 @@ public static void int4x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_and_scalar_wide() { int a0 = (477163326); @@ -1041,7 +1041,7 @@ public static void int4x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_or_wide_wide() { int4x4 a0 = int4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729); @@ -1065,7 +1065,7 @@ public static void int4x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_or_wide_scalar() { int4x4 a0 = int4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773); @@ -1089,7 +1089,7 @@ public static void int4x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_or_scalar_wide() { int a0 = (1768627592); @@ -1113,7 +1113,7 @@ public static void int4x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_xor_wide_wide() { int4x4 a0 = int4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576); @@ -1137,7 +1137,7 @@ public static void int4x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_xor_wide_scalar() { int4x4 a0 = int4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598); @@ -1161,7 +1161,7 @@ public static void int4x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_xor_scalar_wide() { int a0 = (1361775641); @@ -1185,7 +1185,7 @@ public static void int4x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_left_shift() { int4x4 a0 = int4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915); @@ -1209,7 +1209,7 @@ public static void int4x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_right_shift() { int4x4 a0 = int4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287); @@ -1233,7 +1233,7 @@ public static void int4x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4x4_operator_bitwise_not() { int4x4 a0 = int4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736); diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs index 4ba1c895..d22d82a7 100644 --- a/src/Tests/Tests/Shared/TestMath.cs +++ b/src/Tests/Tests/Shared/TestMath.cs @@ -8,7 +8,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestMath { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_uint() { TestUtils.AreEqual(0, asint(0u)); @@ -19,7 +19,7 @@ public static void asint_uint() TestUtils.AreEqual(-1, asint(0xFFFFFFFFu)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_uint2() { TestUtils.AreEqual(int2(0, 0x12345678), asint(uint2(0u, 0x12345678u))); @@ -27,21 +27,21 @@ public static void asint_uint2() TestUtils.AreEqual(int2(-2023406815, -1), asint(uint2(0x87654321u, 0xFFFFFFFFu))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_uint3() { TestUtils.AreEqual(int3(0, 0x12345678, 0x7FFFFFFF), asint(uint3(0u, 0x12345678u, 0x7FFFFFFFu))); TestUtils.AreEqual(int3(-2147483648, -2023406815, -1), asint(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_uint4() { TestUtils.AreEqual(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648), asint(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u))); TestUtils.AreEqual(int4(-2023406815, -1, 0, 0), asint(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_float() { TestUtils.AreEqual(0, asint(0.0f)); @@ -56,14 +56,14 @@ public static void asint_float() TestUtils.AreEqual(unchecked((int)0xFF800000), asint(float.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float_signed_zero() { TestUtils.AreEqual(unchecked((int)0x80000000), asint(TestUtils.SignedFloatZero())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_float2() { TestUtils.AreEqual(int2(0, 0x3F800000), asint(float2(0.0f, 1.0f))); @@ -75,14 +75,14 @@ public static void asint_float2() TestUtils.AreEqual(int2(0, 0), asint(float2(0.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float2_signed_zero() { TestUtils.AreEqual(int2(unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_float3() { TestUtils.AreEqual(int3(0, 0x3F800000, 0x449A51EC), asint(float3(0.0f, 1.0f, 1234.56f))); @@ -91,14 +91,14 @@ public static void asint_float3() TestUtils.AreEqual(int3(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000), 0), asint(float3(-1234.56f, float.NegativeInfinity, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float3_signed_zero() { TestUtils.AreEqual(int3(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asint_float4() { TestUtils.AreEqual(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000), asint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity))); @@ -106,14 +106,14 @@ public static void asint_float4() TestUtils.AreEqual(int4(unchecked((int)0x7FC00000), unchecked((int)0xBF800000), unchecked((int)0xC49A51EC), unchecked((int)0xFF800000)), asint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asint_float4_signed_zero() { TestUtils.AreEqual(int4(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_int() { TestUtils.AreEqual(0u, asuint(0)); @@ -124,7 +124,7 @@ public static void asuint_int() TestUtils.AreEqual(0xFFFFFFFFu, asuint(-1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_int2() { TestUtils.AreEqual(uint2(0u, 0x12345678u), asuint(int2(0, 0x12345678))); @@ -132,21 +132,21 @@ public static void asuint_int2() TestUtils.AreEqual(uint2(0x87654321u, 0xFFFFFFFFu), asuint(int2(-2023406815, -1))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_int3() { TestUtils.AreEqual(uint3(0u, 0x12345678u, 0x7FFFFFFFu), asuint(int3(0, 0x12345678, 0x7FFFFFFF))); TestUtils.AreEqual(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu), asuint(int3(-2147483648, -2023406815, -1))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_int4() { TestUtils.AreEqual(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u), asuint(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648))); TestUtils.AreEqual(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u), asuint(int4(-2023406815, -1, 0, 0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_float() { TestUtils.AreEqual(0u, asuint(0.0f)); @@ -161,14 +161,14 @@ public static void asuint_float() TestUtils.AreEqual(0xFF800000u, asuint(float.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float_signed_zero() { TestUtils.AreEqual(0x80000000u, asuint(TestUtils.SignedFloatZero())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_float2() { TestUtils.AreEqual(uint2(0u, 0x3F800000u), asuint(float2(0.0f, 1.0f))); @@ -179,14 +179,14 @@ public static void asuint_float2() TestUtils.AreEqual(uint2(0xC49A51ECu, 0xFF800000u), asuint(float2(-1234.56f, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float2_signed_zero() { TestUtils.AreEqual(uint2(0x80000000u, 0x80000000u), asuint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_float3() { TestUtils.AreEqual(uint3(0u, 0x3F800000u, 0x449A51ECu), asuint(float3(0.0f, 1.0f, 1234.56f))); @@ -195,14 +195,14 @@ public static void asuint_float3() TestUtils.AreEqual(uint3(0xC49A51ECu, 0xff800000u, 0u), asuint(float3(-1234.56f, float.NegativeInfinity, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float3_signed_zero() { TestUtils.AreEqual(uint3(0x80000000u, 0x80000000u, 0x80000000u), asuint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asuint_float4() { TestUtils.AreEqual(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u), asuint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity))); @@ -210,14 +210,14 @@ public static void asuint_float4() TestUtils.AreEqual(uint4(0x7FC00000u, 0xBF800000u, 0xC49A51ECu, 0xFF800000u), asuint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asuint_float4_singed_zero() { TestUtils.AreEqual(uint4(0x80000000u, 0x80000000u, 0x80000000u, 0x80000000u), asuint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void aslong_ulong() { TestUtils.AreEqual(0L, aslong(0ul)); @@ -228,7 +228,7 @@ public static void aslong_ulong() TestUtils.AreEqual(-1L, aslong(0xFFFFFFFFFFFFFFFFul)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void aslong_double() { TestUtils.AreEqual(0L, aslong(0.0)); @@ -242,14 +242,14 @@ public static void aslong_double() TestUtils.AreEqual(unchecked((long)0xFFF0000000000000UL), aslong(double.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void aslong_double_signed_zero() { TestUtils.AreEqual(unchecked((long)0x8000000000000000UL), aslong(TestUtils.SignedDoubleZero())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asulong_long() { TestUtils.AreEqual(0ul, asulong(0L)); @@ -260,7 +260,7 @@ public static void asulong_long() TestUtils.AreEqual(0xFFFFFFFFFFFFFFFFul, asulong(-1L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asulong_double() { TestUtils.AreEqual(0UL, asulong(0.0)); @@ -274,14 +274,14 @@ public static void asulong_double() TestUtils.AreEqual(0xFFF0000000000000UL, asulong(double.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void asulong_double_signed_zero() { TestUtils.AreEqual(0x8000000000000000UL, asulong(TestUtils.SignedDoubleZero())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_int() { TestUtils.AreEqual(0.0f, asfloat(0)); @@ -297,7 +297,7 @@ public static void asfloat_int() TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(unchecked((int)0x7FC00000)))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_int2() { TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(int2(0, 0x3F800000))); @@ -309,7 +309,7 @@ public static void asfloat_int2() TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int2(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_int3() { TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(int3(0, 0x3F800000, 0x449A51EC))); @@ -320,7 +320,7 @@ public static void asfloat_int3() TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int3(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_int4() { TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000))); @@ -330,7 +330,7 @@ public static void asfloat_int4() TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int4(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_uint() { TestUtils.AreEqual(0.0f, asfloat(0u)); @@ -346,7 +346,7 @@ public static void asfloat_uint() TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(0x7FC00000u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_uint2() { TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(uint2(0u, 0x3F800000u))); @@ -358,7 +358,7 @@ public static void asfloat_uint2() TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint2(0x7FC00000u, 0x7FC00000u)))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_uint3() { TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(uint3(0u, 0x3F800000u, 0x449A51ECu))); @@ -369,7 +369,7 @@ public static void asfloat_uint3() TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint3(0x7FC00000u, 0x7FC00000u, 0x7FC00000u)))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asfloat_uint4() { TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u))); @@ -379,7 +379,7 @@ public static void asfloat_uint4() TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint4(0x7FC00000u, 0x7FC00000u, 0x7FC00000u, 0x7FC00000u)))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asdouble_long() { TestUtils.AreEqual(0.0, asdouble(0L)); @@ -394,7 +394,7 @@ public static void asdouble_long() TestUtils.AreEqual(double.NegativeInfinity, asdouble(unchecked((long)0xFFF0000000000000UL))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void asdouble_ulong() { TestUtils.AreEqual(0.0, asdouble(0UL)); @@ -409,7 +409,7 @@ public static void asdouble_ulong() TestUtils.AreEqual(double.NegativeInfinity, asdouble(0xFFF0000000000000UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void faceforward_float2() { TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(3.0f, -4.0f))); @@ -417,7 +417,7 @@ public static void faceforward_float2() TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(0.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void faceforward_float3() { TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(3.0f, -4.0f, 5.0f))); @@ -425,7 +425,7 @@ public static void faceforward_float3() TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(0.0f, 0.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void faceforward_float4() { TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(3.0f, -4.0f, 5.0f, -6.0f))); @@ -433,7 +433,7 @@ public static void faceforward_float4() TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(0.0f, 0.0f, 0.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void faceforward_double2() { TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(3.0, -4.0))); @@ -441,7 +441,7 @@ public static void faceforward_double2() TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(0.0, 0.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void faceforward_double3() { TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(3.0, -4.0, 5.0))); @@ -449,7 +449,7 @@ public static void faceforward_double3() TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(0.0, 0.0, 0.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void faceforward_double4() { TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(3.0, -4.0, 5.0, -6.0))); @@ -457,7 +457,7 @@ public static void faceforward_double4() TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(0.0, 0.0, 0.0, 0.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_float() { float f, i; @@ -474,7 +474,7 @@ public static void modf_float() TestUtils.AreEqual(0.0f, f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_float2() { float2 f, i; @@ -487,7 +487,7 @@ public static void modf_float2() TestUtils.AreEqual(float2(0.0f, 0.5f), f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_float3() { float3 f, i; @@ -496,7 +496,7 @@ public static void modf_float3() TestUtils.AreEqual(float3(0.75f, -0.25f, 0.0f), f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_float4() { float4 f, i; @@ -505,7 +505,7 @@ public static void modf_float4() TestUtils.AreEqual(float4(0.75f, -0.25f, 0.0f, 0.5f), f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_double() { double f, i; @@ -522,7 +522,7 @@ public static void modf_double() TestUtils.AreEqual(0.0, f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_double2() { double2 f, i; @@ -535,7 +535,7 @@ public static void modf_double2() TestUtils.AreEqual(double2(0.0, 0.5), f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_double3() { double3 f, i; @@ -544,7 +544,7 @@ public static void modf_double3() TestUtils.AreEqual(double3(0.75, -0.25, 0.0), f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void modf_double4() { double4 f, i; @@ -553,21 +553,21 @@ public static void modf_double4() TestUtils.AreEqual(double4(0.75, -0.25, 0.0, 0.5f), f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_float2() { TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalize(float2(3.1f, -5.3f)), 0.0001f); TestUtils.AreEqual(true, all(isnan(normalize(float2(0.0f, 0.0f))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_float3() { TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f); TestUtils.AreEqual(true, all(isnan(normalize(float3(0.0f, 0.0f, 0.0f))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_float4() { TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -575,28 +575,28 @@ public static void normalize_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_double2() { TestUtils.AreEqual(double2(0.504883, -0.863188), normalize(double2(3.1, -5.3)), 0.0001); TestUtils.AreEqual(true, all(isnan(normalize(double2(0.0, 0.0))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_double3() { TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001); TestUtils.AreEqual(true, all(isnan(normalize(double3(0.0, 0.0, 0.0))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_double4() { TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001); TestUtils.AreEqual(true, all(isnan(normalize(double4(0.0, 0.0, 0.0, 0.0f))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalize_quaternion() { TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -604,7 +604,7 @@ public static void normalize_quaternion() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_float2() { TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalizesafe(float2(3.1f, -5.3f)), 0.0001f); @@ -614,7 +614,7 @@ public static void normalizesafe_float2() TestUtils.AreEqual(float2(1.0f, 2.0f), normalizesafe(float2(7.66e-20f, 7.66e-20f), float2(1.0f, 2.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_float3() { TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f); @@ -624,7 +624,7 @@ public static void normalizesafe_float3() TestUtils.AreEqual(float3(1.0f, 2.0f, 3.0f), normalizesafe(float3(6.25e-20f, 6.25e-20f, 6.25e-20f), float3(1.0f, 2.0f, 3.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_float4() { TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -635,7 +635,7 @@ public static void normalizesafe_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_double2() { TestUtils.AreEqual(double2(0.504883, -0.863188), normalizesafe(double2(3.1, -5.3)), 0.0001); @@ -645,7 +645,7 @@ public static void normalizesafe_double2() TestUtils.AreEqual(double2(1.0, 2.0), normalizesafe(double2(1.05e-154, 1.05e-154), double2(1.0, 2.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_double3() { TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001); @@ -655,7 +655,7 @@ public static void normalizesafe_double3() TestUtils.AreEqual(double3(1.0, 2.0, 3.0), normalizesafe(double3(8.61e-155, 8.61e-155, 8.61e-155), double3(1.0, 2.0, 3.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_double4() { TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001); @@ -665,7 +665,7 @@ public static void normalizesafe_double4() TestUtils.AreEqual(double4(1.0, 2.0, 3.0, 4.0), normalizesafe(double4(7.45e-155, 7.45e-155, 7.45e-155, 7.45e-155), double4(1.0, 2.0, 3.0, 4.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void normalizesafe_quaternion() { TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f); @@ -675,7 +675,7 @@ public static void normalizesafe_quaternion() TestUtils.AreEqual(quaternion(1.0f, 2.0f, 3.0f, 4.0f), normalizesafe(quaternion(5.42e-20f, 5.42e-20f, 5.42e-20f, 5.42e-20f), quaternion(1.0f, 2.0f, 3.0f, 4.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f16tof32_float() { TestUtils.AreEqual(0x00000000, asuint(f16tof32(0x0000))); @@ -693,7 +693,7 @@ public static void f16tof32_float() TestUtils.AreEqual(true, isnan(f16tof32(0xFC01))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f16tof32_float2() { TestUtils.AreEqual(uint2(0x00000000, 0x3800C000), asuint(f16tof32(uint2(0x0000, 0x0203)))); @@ -707,7 +707,7 @@ public static void f16tof32_float2() TestUtils.AreEqual(true, all(isnan(f16tof32(uint2(0xFC01, 0xFC01))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f16tof32_float3() { TestUtils.AreEqual(uint3(0x00000000, 0x3800C000, 0x40642000), asuint(f16tof32(uint3(0x0000, 0x0203, 0x4321)))); @@ -719,7 +719,7 @@ public static void f16tof32_float3() TestUtils.AreEqual(true, all(isnan(f16tof32(uint3(0xFC01, 0xFC01, 0xFC01))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f16tof32_float4() { TestUtils.AreEqual(uint4(0x00000000, 0x3800C000, 0x40642000, 0x477FE000), asuint(f16tof32(uint4(0x0000, 0x0203, 0x4321, 0x7BFF)))); @@ -731,7 +731,7 @@ public static void f16tof32_float4() TestUtils.AreEqual(true, all(isnan(f16tof32(uint4(0xFC01, 0xFC01, 0xFC01, 0xFC01))))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f32tof16_float() { TestUtils.AreEqual(0x0000, f32tof16(0.0f)); @@ -751,14 +751,14 @@ public static void f32tof16_float() TestUtils.AreEqual(0xFC00, f32tof16(float.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float_signed_zero() { TestUtils.AreEqual(0x8000, f32tof16(TestUtils.SignedFloatZero())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f32tof16_float2() { TestUtils.AreEqual(uint2(0x0000, 0x0000), f32tof16(float2(0.0f, 2.98e-08f))); @@ -772,14 +772,14 @@ public static void f32tof16_float2() TestUtils.AreEqual(uint2(0xFC00, 0x0000), f32tof16(float2(float.NegativeInfinity, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float2_signed_zero() { TestUtils.AreEqual(uint2(0x8000, 0x8000), f32tof16(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f32tof16_float3() { TestUtils.AreEqual(uint3(0x0000, 0x0000, 0x0001), f32tof16(float3(0.0f, 2.98e-08f, 5.96046448e-08f))); @@ -790,14 +790,14 @@ public static void f32tof16_float3() TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), f32tof16(float3(-65520.0f, float.NegativeInfinity, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float3_signed_zero() { TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), f32tof16(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void f32tof16_float4() { TestUtils.AreEqual(uint4(0x0000, 0x0000, 0x0001, 0x57B6), f32tof16(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f))); @@ -806,14 +806,14 @@ public static void f32tof16_float4() TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), f32tof16(float4(-65520.0f, float.NegativeInfinity, float.NegativeInfinity, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void f32tof16_float4_signed_zero() { TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), f32tof16(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reflect_float2() { TestUtils.AreEqual(float2(9.84f, -3.888f), reflect(float2(1.2f, 3.6f), float2(1.5f, -1.3f)), 8, false); @@ -822,7 +822,7 @@ public static void reflect_float2() TestUtils.AreEqual(float2(0.0f, 0.0f), reflect(float2(0.0f, 0.0f), float2(-1.5f, -1.3f)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reflect_float3() { TestUtils.AreEqual(float3(35.88f, -26.456f, 68.872f), reflect(float3(1.2f, 3.6f, -2.8f), float3(1.5f, -1.3f, 3.1f)), 8, false); @@ -831,7 +831,7 @@ public static void reflect_float3() TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), reflect(float3(0.0f, 0.0f, 0.0f), float3(-1.5f, -1.3f, 3.1f)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reflect_float4() { TestUtils.AreEqual(float4(36.51f, -27.002f, 70.174f, -16.178f), reflect(float4(1.2f, 3.6f, -2.8f, 0.3f), float4(1.5f, -1.3f, 3.1f, -0.7f)), 8, false); @@ -841,7 +841,7 @@ public static void reflect_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reflect_double2() { TestUtils.AreEqual(double2(9.84, -3.888), reflect(double2(1.2, 3.6), double2(1.5, -1.3)), 8, false); @@ -850,7 +850,7 @@ public static void reflect_double2() TestUtils.AreEqual(double2(0.0, 0.0), reflect(double2(0.0, 0.0), double2(-1.5, -1.3)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reflect_double3() { TestUtils.AreEqual(double3(35.88, -26.456, 68.872), reflect(double3(1.2, 3.6, -2.8), double3(1.5, -1.3, 3.1)), 8, false); @@ -859,7 +859,7 @@ public static void reflect_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), reflect(double3(0.0, 0.0, 0.0), double3(-1.5f, -1.3, 3.1)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void reflect_double4() { TestUtils.AreEqual(double4(36.51, -27.002, 70.174, -16.178), reflect(double4(1.2, 3.6, -2.8, 0.3), double4(1.5, -1.3, 3.1, -0.7)), 8, false); @@ -869,7 +869,7 @@ public static void reflect_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void refract_float2() { TestUtils.AreEqual(float2(-0.3676186f, 0.9299768f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 0.5f), 8, false); @@ -877,7 +877,7 @@ public static void refract_float2() TestUtils.AreEqual(float2(0.0f, 0.0f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 1.5f)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void refract_float3() { TestUtils.AreEqual(float3(-0.2863437f, 0.8056898f, -0.5185286f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 0.5f), 8, false); @@ -885,7 +885,7 @@ public static void refract_float3() TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 1.5f)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void refract_float4() { TestUtils.AreEqual(float4(-0.302029191645545f, 0.799522577847971f, -0.518952508802814f, -0.015196476378571f), refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.1726139f), 0.5f), 16, false); @@ -894,7 +894,7 @@ public static void refract_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void refract_double2() { TestUtils.AreEqual(double2(-0.367618540673032, 0.929976739623085), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 0.5), 8, false); @@ -902,7 +902,7 @@ public static void refract_double2() TestUtils.AreEqual(double2(0.0, 0.0), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 1.5)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void refract_double3() { TestUtils.AreEqual(double3(-0.286343746291412, 0.805689753507206, -0.518528611485079), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 0.5), 8, false); @@ -910,7 +910,7 @@ public static void refract_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 1.5)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void refract_double4() { TestUtils.AreEqual(double4(-0.302029191645545, 0.799522577847971, -0.518952508802814, -0.015196476378571), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.1726139), 0.5), 16, false); @@ -918,7 +918,7 @@ public static void refract_double4() TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.172613), 1.5)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void project_float2() { var a = float2(-0.161021441221237182617f, 0.429202795028686523438f); @@ -927,7 +927,7 @@ public static void project_float2() TestUtils.AreEqual(float2(1.0f, 0.0f), project(float2(1.0f), float2(1.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void project_float3() { var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f); @@ -936,7 +936,7 @@ public static void project_float3() TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), project(float3(1.0f), float3(1.0f, 0.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void project_float4() { var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f); @@ -945,7 +945,7 @@ public static void project_float4() TestUtils.AreEqual(float4(1.0f, 0.0f, 0.0f, 0.0f), project(float4(1.0f), float4(1.0f, 0.0f, 0.0f, 0.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void projectsafe_float2() { var a = float2(-0.161021441221237182617f, 0.429202795028686523438f); @@ -957,7 +957,7 @@ public static void projectsafe_float2() TestUtils.AreEqual(float2(4.0f), projectsafe(float2(NAN), float2(0.0f), float2(4.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void projectsafe_float3() { var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f); @@ -969,7 +969,7 @@ public static void projectsafe_float3() TestUtils.AreEqual(float3(4.0f), projectsafe(float3(NAN), float3(0.0f), float3(4.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void projectsafe_float4() { var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f); @@ -981,7 +981,7 @@ public static void projectsafe_float4() TestUtils.AreEqual(float4(4.0f), projectsafe(float4(NAN), float4(0.0f), float4(4.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void project_double2() { var a = double2(-0.435219509355847911092, -0.359623376546357509387); @@ -991,7 +991,7 @@ public static void project_double2() TestUtils.AreEqual(double2.zero, projectsafe(a, double2(DBL_MIN_NORMAL))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void project_double3() { var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805); @@ -1001,7 +1001,7 @@ public static void project_double3() TestUtils.AreEqual(double3.zero, projectsafe(a, double3(DBL_MIN_NORMAL))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void project_double4() { var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997); @@ -1011,7 +1011,7 @@ public static void project_double4() TestUtils.AreEqual(double4.zero, projectsafe(a, double4(DBL_MIN_NORMAL))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void projectsafe_double2() { var a = double2(-0.435219509355847911092, -0.359623376546357509387); @@ -1023,7 +1023,7 @@ public static void projectsafe_double2() TestUtils.AreEqual(double2(4.0), projectsafe(double2(NAN_DBL), double2(0.0), double2(4.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void projectsafe_double3() { var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805); @@ -1035,7 +1035,7 @@ public static void projectsafe_double3() TestUtils.AreEqual(double3(4.0), projectsafe(double3(NAN_DBL), double3(0.0), double3(4.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void projectsafe_double4() { var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997); @@ -1047,7 +1047,7 @@ public static void projectsafe_double4() TestUtils.AreEqual(double4(4.0), projectsafe(double4(NAN_DBL), double4(0.0), double4(4.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_float() { float s, c; @@ -1086,7 +1086,7 @@ public static void sincos_float() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_float2() { float2 s, c; @@ -1108,7 +1108,7 @@ public static void sincos_float2() TestUtils.AreEqual(float2(float.NaN, float.NaN), c, 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_float3() { float3 s, c; @@ -1126,7 +1126,7 @@ public static void sincos_float3() TestUtils.AreEqual(float3(float.NaN, float.NaN, float.NaN), c, 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_float4() { float4 s, c; @@ -1140,7 +1140,7 @@ public static void sincos_float4() TestUtils.AreEqual(float4(0.936752141f, float.NaN, float.NaN, float.NaN), c, 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_double() { double s, c; @@ -1177,7 +1177,7 @@ public static void sincos_double() TestUtils.AreEqual(double.NaN, c, 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_double2() { double2 s, c; @@ -1198,7 +1198,7 @@ public static void sincos_double2() TestUtils.AreEqual(double2(double.NaN, double.NaN), c, 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_double3() { double3 s, c; @@ -1216,7 +1216,7 @@ public static void sincos_double3() TestUtils.AreEqual(double3(double.NaN, double.NaN, double.NaN), c, 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sincos_double4() { double4 s, c; @@ -1230,14 +1230,14 @@ public static void sincos_double4() TestUtils.AreEqual(double4(0.93675212753314474, double.NaN, double.NaN, double.NaN), c, 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_int() { TestUtils.AreEqual(-123456789, select(-123456789, 987654321, false)); TestUtils.AreEqual(987654321, select(-123456789, 987654321, true)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_int2() { TestUtils.AreEqual(int2(-123456789, -123456790), select(int2(-123456789, -123456790), int2(987654321, 987654322), false)); @@ -1249,7 +1249,7 @@ public static void select_int2() TestUtils.AreEqual(int2(987654321, 987654322), select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_int3() { TestUtils.AreEqual(int3(-123456789, -123456790, -123456791), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), false)); @@ -1266,7 +1266,7 @@ public static void select_int3() TestUtils.AreEqual(int3(987654321, 987654322, 987654323), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_int4() { TestUtils.AreEqual(int4(-123456789, -123456790, -123456791, -123456792), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), false)); @@ -1293,14 +1293,14 @@ public static void select_int4() TestUtils.AreEqual(int4(987654321, 987654322, 987654323, 987654324), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_uint() { TestUtils.AreEqual(123456789u, select(123456789u, 987654321u, false)); TestUtils.AreEqual(987654321u, select(123456789u, 987654321u, true)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_uint2() { TestUtils.AreEqual(uint2(123456789u, 123456790u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), false)); @@ -1312,7 +1312,7 @@ public static void select_uint2() TestUtils.AreEqual(uint2(987654321u, 987654322u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_uint3() { TestUtils.AreEqual(uint3(123456789u, 123456790u, 123456791u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), false)); @@ -1329,7 +1329,7 @@ public static void select_uint3() TestUtils.AreEqual(uint3(987654321u, 987654322u, 987654323u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_uint4() { TestUtils.AreEqual(uint4(123456789u, 123456790u, 123456791u, 123456792u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), false)); @@ -1356,14 +1356,14 @@ public static void select_uint4() TestUtils.AreEqual(uint4(987654321u, 987654322u, 987654323u, 987654324u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_long() { TestUtils.AreEqual(-12345678910111314L, select(-12345678910111314L, 987654321011121314L, false)); TestUtils.AreEqual(987654321011121314L, select(-12345678910111314L, 987654321011121314L, true)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_ulong() { TestUtils.AreEqual(12345678910111314UL, select(12345678910111314UL, 987654321011121314UL, false)); @@ -1371,14 +1371,14 @@ public static void select_ulong() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_float() { TestUtils.AreEqual(-1234.5f, select(-1234.5f, 9876.25f, false)); TestUtils.AreEqual(9876.25f, select(-1234.5f, 9876.25f, true)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_float2() { TestUtils.AreEqual(float2(-1234.5f, -1235.5f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), false)); @@ -1390,7 +1390,7 @@ public static void select_float2() TestUtils.AreEqual(float2(9876.25f, 9877.25f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_float3() { TestUtils.AreEqual(float3(-1234.5f, -1235.5f, -1236.5f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), false)); @@ -1407,7 +1407,7 @@ public static void select_float3() TestUtils.AreEqual(float3(9876.25f, 9877.25f, 9878.25f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_float4() { TestUtils.AreEqual(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), false)); @@ -1435,14 +1435,14 @@ public static void select_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_double() { TestUtils.AreEqual(-1234.5, select(-1234.5, 9876.25, false)); TestUtils.AreEqual(9876.25, select(-1234.5, 9876.25, true)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_double2() { TestUtils.AreEqual(double2(-1234.5, -1235.5), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), false)); @@ -1454,7 +1454,7 @@ public static void select_double2() TestUtils.AreEqual(double2(9876.25, 9877.25), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_double3() { TestUtils.AreEqual(double3(-1234.5, -1235.5, -1236.5), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), false)); @@ -1471,7 +1471,7 @@ public static void select_double3() TestUtils.AreEqual(double3(9876.25, 9877.25, 9878.25), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void select_double4() { TestUtils.AreEqual(double4(-1234.5, -1235.5, -1236.5, -1237.5), select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), false)); @@ -1499,7 +1499,7 @@ public static void select_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_int() { TestUtils.AreEqual(133, dot(7, 19)); @@ -1508,7 +1508,7 @@ public static void dot_int() TestUtils.AreEqual(667585376, dot(61031, 81312)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_int2() { TestUtils.AreEqual(322, dot(int2(7, 9), int2(19, 21))); @@ -1517,7 +1517,7 @@ public static void dot_int2() TestUtils.AreEqual(1840235232, dot(int2(61031, -12534), int2(-41312, -5312))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_int3() { TestUtils.AreEqual(582, dot(int3(7, 9, 13), int3(19, 21, 20))); @@ -1526,7 +1526,7 @@ public static void dot_int3() TestUtils.AreEqual(1636460279, dot(int3(61031, -12534, 9211), int3(-41312, -5312, -22123))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_int4() { TestUtils.AreEqual(990, dot(int4(7, 9, 13, 17), int4(19, 21, 20, 24))); @@ -1536,28 +1536,28 @@ public static void dot_int4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_uint() { TestUtils.AreEqual(133u, dot(7u, 19u)); TestUtils.AreEqual(667585376u, dot(61031u, 81312u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_uint2() { TestUtils.AreEqual(322, dot(uint2(7u, 9u), uint2(19u, 21u))); TestUtils.AreEqual(734165984u, dot(uint2(61031u, 12534u), uint2(81312u, 5312u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_uint3() { TestUtils.AreEqual(582u, dot(uint3(7u, 9u, 13u), uint3(19u, 21u, 20u))); TestUtils.AreEqual(937940937u, dot(uint3(61031u, 12534u, 9211u), uint3(81312u, 5312u, 22123u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_uint4() { TestUtils.AreEqual(990u, dot(uint4(7u, 9u, 13u, 17u), uint4(19u, 21u, 20u, 24u))); @@ -1565,7 +1565,7 @@ public static void dot_uint4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_float() { TestUtils.AreEqual(7.32f, dot(1.2f, 6.1f), 1, false); @@ -1576,7 +1576,7 @@ public static void dot_float() TestUtils.AreEqual(float.NegativeInfinity, dot(1.2e19f, -6.1e19f), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_float2() { TestUtils.AreEqual(57.92f, dot(float2(1.2f, 5.5f), float2(6.1f, 9.2f)), 1, false); @@ -1587,7 +1587,7 @@ public static void dot_float2() TestUtils.AreEqual(float.NegativeInfinity, dot(float2(-1.2e18f, 5.5e18f), float2(6.1e19f, -9.2e19f)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_float3() { TestUtils.AreEqual(67.1f, dot(float3(1.2f, 5.5f, 3.4f), float3(6.1f, 9.2f, 2.7f)), 8, false); @@ -1598,7 +1598,7 @@ public static void dot_float3() TestUtils.AreEqual(float.NegativeInfinity, dot(float3(-1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e19f, -9.2e19f, -2.7e19f)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_float4() { TestUtils.AreEqual(68.57f, dot(float4(1.2f, 5.5f, 3.4f, 4.9f), float4(6.1f, 9.2f, 2.7f, 0.3f)), 8, false); @@ -1620,7 +1620,7 @@ public static void dot_double() TestUtils.AreEqual(double.NegativeInfinity, dot(1.2e19, -6.1e19), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_double2() { TestUtils.AreEqual(57.92, dot(double2(1.2, 5.5), double2(6.1, 9.2)), 1, false); @@ -1631,7 +1631,7 @@ public static void dot_double2() TestUtils.AreEqual(double.NegativeInfinity, dot(double2(-1.2e153, 5.5e153), double2(6.1e154, -9.2e154)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_double3() { TestUtils.AreEqual(67.1, dot(double3(1.2, 5.5, 3.4), double3(6.1, 9.2, 2.7)), 8, false); @@ -1642,7 +1642,7 @@ public static void dot_double3() TestUtils.AreEqual(double.NegativeInfinity, dot(double3(-1.2e153, 5.5e153, 3.4e153), double3(6.1e154, -9.2e154, -2.7e154)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void dot_double4() { TestUtils.AreEqual(68.57, dot(double4(1.2, 5.5, 3.4, 4.9), double4(6.1, 9.2, 2.7, 0.3)), 8, false); @@ -1653,7 +1653,7 @@ public static void dot_double4() TestUtils.AreEqual(double.NegativeInfinity, dot(double4(-1.2e153, 5.5e153, 3.4e153, -4.9e153), double4(6.1e154, -9.2e154, -2.7e154, 3e153)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_int2() { TestUtils.AreEqual(100, cmin(int2(100, 200))); @@ -1664,7 +1664,7 @@ public static void cmin_int2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_int3() { TestUtils.AreEqual(100, cmin(int3(100, 200, 300))); @@ -1675,7 +1675,7 @@ public static void cmin_int3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_int4() { TestUtils.AreEqual(100, cmin(int4(100, 200, 300, 400))); @@ -1685,7 +1685,7 @@ public static void cmin_int4() TestUtils.AreEqual(int.MinValue, cmin(int4(int.MaxValue, int.MinValue, 0, 19))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_uint2() { TestUtils.AreEqual(100u, cmin(uint2(100u, 200u))); @@ -1694,7 +1694,7 @@ public static void cmin_uint2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_uint3() { TestUtils.AreEqual(100u, cmin(uint3(100u, 200u, 300u))); @@ -1703,7 +1703,7 @@ public static void cmin_uint3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_uint4() { TestUtils.AreEqual(100u, cmin(uint4(100u, 200u, 300u, 400u))); @@ -1711,7 +1711,7 @@ public static void cmin_uint4() TestUtils.AreEqual(uint.MinValue, cmin(uint4(19u, uint.MinValue, uint.MaxValue, 7u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_float2() { TestUtils.AreEqual(-0.5f, cmin(float2(5.2f, -0.5f))); @@ -1730,7 +1730,7 @@ public static void cmin_float2() TestUtils.AreEqual(float.NegativeInfinity, cmin(float2(float.NaN, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_float3() { TestUtils.AreEqual(-1.2f, cmin(float3(5.2f, -0.5f, -1.2f))); @@ -1750,7 +1750,7 @@ public static void cmin_float3() TestUtils.AreEqual(float.NegativeInfinity, cmin(float3(float.NaN, float.NaN, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_float4() { TestUtils.AreEqual(-1.2f, cmin(float4(5.2f, -0.5f, -1.2f, 2.3f))); @@ -1773,7 +1773,7 @@ public static void cmin_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_double2() { TestUtils.AreEqual(-0.5, cmin(double2(5.2, -0.5))); @@ -1793,7 +1793,7 @@ public static void cmin_double2() TestUtils.AreEqual(double.NegativeInfinity, cmin(double2(double.NaN, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_double3() { TestUtils.AreEqual(-1.2, cmin(double3(5.2, -0.5, -1.2))); @@ -1814,7 +1814,7 @@ public static void cmin_double3() TestUtils.AreEqual(double.NegativeInfinity, cmin(double3(double.NaN, double.NaN, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmin_double4() { TestUtils.AreEqual(-1.2, cmin(double4(5.2, -0.5, -1.2, 2.3))); @@ -1839,7 +1839,7 @@ public static void cmin_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_int2() { TestUtils.AreEqual(200, cmax(int2(100, 200))); @@ -1850,7 +1850,7 @@ public static void cmax_int2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_int3() { TestUtils.AreEqual(300, cmax(int3(100, 200, 300))); @@ -1861,7 +1861,7 @@ public static void cmax_int3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_int4() { TestUtils.AreEqual(400, cmax(int4(100, 200, 300, 400))); @@ -1871,7 +1871,7 @@ public static void cmax_int4() TestUtils.AreEqual(int.MaxValue, cmax(int4(int.MaxValue, int.MinValue, 0, 19))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_uint2() { TestUtils.AreEqual(200u, cmax(uint2(100u, 200u))); @@ -1880,7 +1880,7 @@ public static void cmax_uint2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_uint3() { TestUtils.AreEqual(300u, cmax(uint3(100u, 200u, 300u))); @@ -1889,7 +1889,7 @@ public static void cmax_uint3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_uint4() { TestUtils.AreEqual(400u, cmax(uint4(100u, 200u, 300u, 400u))); @@ -1897,7 +1897,7 @@ public static void cmax_uint4() TestUtils.AreEqual(uint.MaxValue, cmax(uint4(19u, uint.MinValue, uint.MaxValue, 7u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_float2() { TestUtils.AreEqual(5.2f, cmax(float2(5.2f, -0.5f))); @@ -1916,7 +1916,7 @@ public static void cmax_float2() TestUtils.AreEqual(float.NegativeInfinity, cmax(float2(float.NaN, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_float3() { TestUtils.AreEqual(5.2f, cmax(float3(5.2f, -0.5f, -1.2f))); @@ -1936,7 +1936,7 @@ public static void cmax_float3() TestUtils.AreEqual(float.NegativeInfinity, cmax(float3(float.NaN, float.NaN, float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_float4() { TestUtils.AreEqual(5.2f, cmax(float4(5.2f, -0.5f, -1.2f, 2.3f))); @@ -1959,7 +1959,7 @@ public static void cmax_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_double2() { TestUtils.AreEqual(5.2, cmax(double2(5.2, -0.5))); @@ -1979,7 +1979,7 @@ public static void cmax_double2() TestUtils.AreEqual(double.NegativeInfinity, cmax(double2(double.NaN, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_double3() { TestUtils.AreEqual(5.2, cmax(double3(5.2, -0.5, -1.2))); @@ -2000,7 +2000,7 @@ public static void cmax_double3() TestUtils.AreEqual(double.NegativeInfinity, cmax(double3(double.NaN, double.NaN, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cmax_double4() { TestUtils.AreEqual(5.2, cmax(double4(5.2, -0.5, -1.2, 2.3))); @@ -2024,7 +2024,7 @@ public static void cmax_double4() TestUtils.AreEqual(double.NegativeInfinity, cmax(double4(double.NaN, double.NaN, double.NaN, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_int2() { TestUtils.AreEqual(300, csum(int2(100, 200))); @@ -2035,7 +2035,7 @@ public static void csum_int2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_int3() { TestUtils.AreEqual(600, csum(int3(100, 200, 300))); @@ -2046,7 +2046,7 @@ public static void csum_int3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_int4() { TestUtils.AreEqual(1000, csum(int4(100, 200, 300, 400))); @@ -2056,7 +2056,7 @@ public static void csum_int4() TestUtils.AreEqual(-1, csum(int4(int.MaxValue, int.MinValue, 0, 0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_uint2() { TestUtils.AreEqual(300u, csum(uint2(100u, 200u))); @@ -2064,7 +2064,7 @@ public static void csum_uint2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_uint3() { TestUtils.AreEqual(600u, csum(uint3(100u, 200u, 300u))); @@ -2072,14 +2072,14 @@ public static void csum_uint3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_uint4() { TestUtils.AreEqual(1000u, csum(uint4(100u, 200u, 300u, 400u))); TestUtils.AreEqual(36u, csum(uint4(uint.MaxValue, 7u, 11u, 19u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_float2() { TestUtils.AreEqual(0.7f, csum(float2(2.2f, -1.5f)), 4, false); @@ -2102,7 +2102,7 @@ public static void csum_float2() TestUtils.AreEqual(float.NegativeInfinity, csum(float2(-1.0f, float.NegativeInfinity)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_float3() { TestUtils.AreEqual(1.9f, csum(float3(2.2f, -1.5f, 1.2f)), 4, false); @@ -2126,7 +2126,7 @@ public static void csum_float3() TestUtils.AreEqual(float.NegativeInfinity, csum(float3(-2.0f, 1.0f, float.NegativeInfinity)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_float4() { TestUtils.AreEqual(1.2f, csum(float4(2.2f, -1.5f, 1.2f, -0.7f)), 4, false); @@ -2153,7 +2153,7 @@ public static void csum_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_double2() { TestUtils.AreEqual(0.7, csum(double2(2.2, -1.5)), 4, false); @@ -2176,7 +2176,7 @@ public static void csum_double2() TestUtils.AreEqual(double.NegativeInfinity, csum(double2(-1.0, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_double3() { TestUtils.AreEqual(1.9, csum(double3(2.2, -1.5, 1.2)), 4, false); @@ -2200,7 +2200,7 @@ public static void csum_double3() TestUtils.AreEqual(double.NegativeInfinity, csum(double3(-2.0, 1.0, double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void csum_double4() { TestUtils.AreEqual(1.2, csum(double4(2.2, -1.5, 1.2, -0.7)), 4, false); @@ -2227,7 +2227,7 @@ public static void csum_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_bool2() { TestUtils.AreEqual(false, any(bool2(false, false))); @@ -2236,7 +2236,7 @@ public static void any_bool2() TestUtils.AreEqual(true, any(bool2(true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_bool3() { TestUtils.AreEqual(false, any(bool3(false, false, false))); @@ -2250,7 +2250,7 @@ public static void any_bool3() TestUtils.AreEqual(true, any(bool3(true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_bool4() { TestUtils.AreEqual(false, any(bool4(false, false, false, false))); @@ -2274,7 +2274,7 @@ public static void any_bool4() TestUtils.AreEqual(true, any(bool4(true, true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_int2() { TestUtils.AreEqual(false, any(int2(0, 0))); @@ -2284,7 +2284,7 @@ public static void any_int2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_int3() { TestUtils.AreEqual(false, any(int3(0, 0, 0))); @@ -2298,7 +2298,7 @@ public static void any_int3() TestUtils.AreEqual(true, any(int3(-121, 100, 322))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_int4() { TestUtils.AreEqual(false, any(int4(0, 0, 0, 0))); @@ -2323,7 +2323,7 @@ public static void any_int4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_uint2() { TestUtils.AreEqual(false, any(uint2(0u, 0u))); @@ -2333,7 +2333,7 @@ public static void any_uint2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_uint3() { TestUtils.AreEqual(false, any(uint3(0u, 0u, 0u))); @@ -2347,7 +2347,7 @@ public static void any_uint3() TestUtils.AreEqual(true, any(uint3(121u, 100u, 322u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_uint4() { TestUtils.AreEqual(false, any(uint4(0u, 0u, 0u, 0u))); @@ -2372,7 +2372,7 @@ public static void any_uint4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_float2() { //TestUtils.AreEqual(true, any(float2(0, float.NaN))); // TODO: doesn't work with burst @@ -2384,7 +2384,7 @@ public static void any_float2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_float3() { //TestUtils.AreEqual(true, any(float3(0.0f, float.NaN, 0.0f))); // TODO: doesn't work with burst @@ -2400,7 +2400,7 @@ public static void any_float3() TestUtils.AreEqual(true, any(float3(121.2f, 100.0f, -32.2f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_float4() { TestUtils.AreEqual(false, any(float4(0.0f, 0.0f, 0.0f, 0.0f))); @@ -2424,7 +2424,7 @@ public static void any_float4() TestUtils.AreEqual(true, any(float4(55.0f, 66.0f, 5000.0f, 10000.2f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_double2() { //TestUtils.AreEqual(true, any(double2(0, double.NaN))); // TODO: doesn't work with burst. @@ -2436,7 +2436,7 @@ public static void any_double2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_double3() { //TestUtils.AreEqual(true, any(double3(0.0, double.NaN, 0.0))); // TODO: doesn't work with burst @@ -2452,7 +2452,7 @@ public static void any_double3() TestUtils.AreEqual(true, any(double3(121.2, 100.0, -32.2))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void any_double4() { TestUtils.AreEqual(false, any(double4(0.0, 0.0, 0.0, 0.0))); @@ -2477,7 +2477,7 @@ public static void any_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_bool2() { TestUtils.AreEqual(false, all(bool2(false, false))); @@ -2486,7 +2486,7 @@ public static void all_bool2() TestUtils.AreEqual(true, all(bool2(true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_bool3() { TestUtils.AreEqual(false, all(bool3(false, false, false))); @@ -2500,7 +2500,7 @@ public static void all_bool3() TestUtils.AreEqual(true, all(bool3(true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_bool4() { TestUtils.AreEqual(false, all(bool4(false, false, false, false))); @@ -2524,7 +2524,7 @@ public static void all_bool4() TestUtils.AreEqual(true, all(bool4(true, true, true, true))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_int2() { TestUtils.AreEqual(false, all(int2(0, 0))); @@ -2533,7 +2533,7 @@ public static void all_int2() TestUtils.AreEqual(true, all(int2(2, int.MinValue))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_int3() { TestUtils.AreEqual(false, all(int3(0, 0, 0))); @@ -2547,7 +2547,7 @@ public static void all_int3() TestUtils.AreEqual(true, all(int3(-121, 100, 322))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_int4() { TestUtils.AreEqual(false, all(int4(0, 0, 0, 0))); @@ -2572,7 +2572,7 @@ public static void all_int4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_uint2() { TestUtils.AreEqual(false, all(uint2(0u, 0u))); @@ -2582,7 +2582,7 @@ public static void all_uint2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_uint3() { TestUtils.AreEqual(false, all(uint3(0u, 0u, 0u))); @@ -2596,7 +2596,7 @@ public static void all_uint3() TestUtils.AreEqual(true, all(uint3(121u, 100u, 322u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_uint4() { TestUtils.AreEqual(false, all(uint4(0u, 0u, 0u, 0u))); @@ -2621,7 +2621,7 @@ public static void all_uint4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_float2() { TestUtils.AreEqual(true, all(float2(float.NaN, float.NaN))); @@ -2633,7 +2633,7 @@ public static void all_float2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_float3() { TestUtils.AreEqual(true, all(float3(float.NaN, float.NaN, float.NaN))); @@ -2649,7 +2649,7 @@ public static void all_float3() TestUtils.AreEqual(true, all(float3(121.2f, 100.0f, -32.2f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_float4() { TestUtils.AreEqual(true, all(float4(float.NaN, float.NaN, float.NaN, float.NaN))); @@ -2675,7 +2675,7 @@ public static void all_float4() TestUtils.AreEqual(true, all(float4(55.0f, 66.0f, 5000.0f, 10000.2f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_double2() { TestUtils.AreEqual(true, all(double2(double.NaN, double.NaN))); @@ -2687,7 +2687,7 @@ public static void all_double2() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_double3() { TestUtils.AreEqual(true, all(double3(double.NaN, double.NaN, double.NaN))); @@ -2703,7 +2703,7 @@ public static void all_double3() TestUtils.AreEqual(true, all(double3(121.2, 100.0, -32.2))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void all_double4() { TestUtils.AreEqual(true, all(double4(double.NaN, double.NaN, double.NaN, double.NaN))); @@ -2730,7 +2730,7 @@ public static void all_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void length_float2() { TestUtils.AreEqual(0.0f, length(float2(0.0f, 0.0f)), 0, false); @@ -2743,7 +2743,7 @@ public static void length_float2() TestUtils.AreEqual(double.PositiveInfinity, length(float2(-1.2e19f, -2.6e19f)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void length_float3() { TestUtils.AreEqual(0.0f, length(float3(0.0f, 0.0f, 0.0f)), 0, false); @@ -2756,7 +2756,7 @@ public static void length_float3() TestUtils.AreEqual(float.PositiveInfinity, length(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void length_float4() { TestUtils.AreEqual(0.0f, length(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false); @@ -2770,7 +2770,7 @@ public static void length_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void length_double2() { TestUtils.AreEqual(0.0, length(double2(0.0, 0.0)), 0, false); @@ -2782,7 +2782,7 @@ public static void length_double2() TestUtils.AreEqual(2.86356421265527063e153, length(double2(-1.2e153, 2.6e153)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void length_double3() { TestUtils.AreEqual(0.0, length(double3(0.0, 0.0, 0.0)), 0, false); @@ -2794,7 +2794,7 @@ public static void length_double3() TestUtils.AreEqual(3.6110940170535577e153, length(double3(-1.2e153, 2.6e153, 2.2e153)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void length_double4() { TestUtils.AreEqual(0.0, length(double4(0.0, 0.0, 0.0, 0.0)), 0, false); @@ -2807,7 +2807,7 @@ public static void length_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lengthsq_float2() { TestUtils.AreEqual(0.0f, lengthsq(float2(0.0f, 0.0f)), 0, false); @@ -2819,7 +2819,7 @@ public static void lengthsq_float2() TestUtils.AreEqual(8.2e36f, lengthsq(float2(-1.2e18f, 2.6e18f)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lengthsq_float3() { TestUtils.AreEqual(0.0f, lengthsq(float3(0.0f, 0.0f, 0.0f)), 0, false); @@ -2832,7 +2832,7 @@ public static void lengthsq_float3() TestUtils.AreEqual(float.PositiveInfinity, lengthsq(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lengthsq_float4() { TestUtils.AreEqual(0.0f, lengthsq(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false); @@ -2846,7 +2846,7 @@ public static void lengthsq_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lengthsq_double2() { TestUtils.AreEqual(0.0, lengthsq(double2(0.0, 0.0)), 0, false); @@ -2859,7 +2859,7 @@ public static void lengthsq_double2() TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double2(-1.2e154, -2.6e154)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lengthsq_double3() { TestUtils.AreEqual(0.0, lengthsq(double3(0.0, 0.0, 0.0)), 0, false); @@ -2872,7 +2872,7 @@ public static void lengthsq_double3() TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double3(-1.2e154, -2.6e154, 2.2e154)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lengthsq_double4() { TestUtils.AreEqual(0.0, lengthsq(double4(0.0, 0.0, 0.0, 0.0)), 0, false); @@ -2888,7 +2888,7 @@ public static void lengthsq_double4() - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distance_float2() { TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false); @@ -2902,7 +2902,7 @@ public static void distance_float2() TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distance_float3() { TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false); @@ -2916,7 +2916,7 @@ public static void distance_float3() TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distance_float4() { TestUtils.AreEqual(0.0, distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false); @@ -2931,7 +2931,7 @@ public static void distance_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distance_double2() { TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false); @@ -2944,7 +2944,7 @@ public static void distance_double2() TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distance_double3() { TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false); @@ -2957,7 +2957,7 @@ public static void distance_double3() TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distance_double4() { TestUtils.AreEqual(0.0, distance(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false); @@ -2970,7 +2970,7 @@ public static void distance_double4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distancesq_float2() { TestUtils.AreEqual(0.0f, distancesq(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false); @@ -2982,7 +2982,7 @@ public static void distancesq_float2() TestUtils.AreEqual(float.PositiveInfinity, distancesq(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distancesq_float3() { TestUtils.AreEqual(0.0f, distancesq(float3(1.3f, -2.4f, 5.7f), float3(1.3f, -2.4f, 5.7f)), 0, false); @@ -2995,7 +2995,7 @@ public static void distancesq_float3() TestUtils.AreEqual(float.PositiveInfinity, distancesq(float3(1.3f, -2.4f, 5.7f), float3(-5.3f, float.PositiveInfinity, 4.7f)), 0, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distancesq_float4() { TestUtils.AreEqual(0.0f, distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false); @@ -3008,7 +3008,7 @@ public static void distancesq_float4() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distancesq_double2() { TestUtils.AreEqual(0.0, distancesq(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false); @@ -3022,7 +3022,7 @@ public static void distancesq_double2() TestUtils.AreEqual(double.PositiveInfinity, distancesq(double2(1.3, double.NegativeInfinity), double2(-5.3, 4.3)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distancesq_double3() { TestUtils.AreEqual(0.0, distancesq(double3(1.3, -2.4, 5.7), double3(1.3, -2.4, 5.7)), 0, false); @@ -3036,7 +3036,7 @@ public static void distancesq_double3() TestUtils.AreEqual(double.PositiveInfinity, distancesq(double3(1.3, double.NegativeInfinity, 5.7), double3(-5.3, 4.3, 4.7)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void distancesq_double4() { TestUtils.AreEqual(0.0, distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false); @@ -3050,7 +3050,7 @@ public static void distancesq_double4() TestUtils.AreEqual(double.PositiveInfinity, distancesq(double4(1.3, double.NegativeInfinity, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void epsilon_float() { float next = asfloat(asuint(1.0f) + 1); @@ -3059,7 +3059,7 @@ public static void epsilon_float() TestUtils.IsTrue(Single.Epsilon != EPSILON); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void epsilon_double() { double next = asdouble(aslong(1.0) + 1); @@ -3068,7 +3068,7 @@ public static void epsilon_double() TestUtils.IsTrue(Double.Epsilon != EPSILON_DBL); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void nan_float() { TestUtils.IsFalse(0.0f == NAN); @@ -3093,7 +3093,7 @@ public static void nan_float() TestUtils.IsTrue(nan1 != nan2); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void nan_double() { TestUtils.IsFalse(0.0 == NAN_DBL); @@ -3118,7 +3118,7 @@ public static void nan_double() TestUtils.IsTrue(nan1 != nan2); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void infinity_float() { TestUtils.IsTrue(-INFINITY != INFINITY); @@ -3126,7 +3126,7 @@ public static void infinity_float() TestUtils.IsFalse(isfinite(INFINITY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void infinity_double() { TestUtils.IsTrue(-INFINITY_DBL != INFINITY_DBL); @@ -3134,7 +3134,7 @@ public static void infinity_double() TestUtils.IsFalse(isfinite(INFINITY_DBL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void helper_axes() { TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), right()); @@ -3145,7 +3145,7 @@ public static void helper_axes() TestUtils.AreEqual(float3(0.0f, 0.0f, -1.0f), back()); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float_signed_zero() { @@ -3153,21 +3153,21 @@ public static void rcp_float_signed_zero() TestUtils.AreEqual(TestUtils.SignedFloatZero(), rcp(float.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float2_signed_zero() { TestUtils.AreEqual(float2(float.NegativeInfinity, TestUtils.SignedFloatZero()), rcp(float2(TestUtils.SignedFloatZero(), float.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float3_signed_zero() { TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatZero(), float.NegativeInfinity), rcp(float3(TestUtils.SignedFloatZero(), float.NegativeInfinity, TestUtils.SignedFloatZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_float4_signed_zero() { @@ -3175,7 +3175,7 @@ public static void rcp_float4_signed_zero() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double_signed_zero() { @@ -3183,28 +3183,28 @@ public static void rcp_double_signed_zero() TestUtils.AreEqual(TestUtils.SignedDoubleZero(), rcp(double.NegativeInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double2_signed_zero() { TestUtils.AreEqual(double2(double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double2(TestUtils.SignedDoubleZero(), double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double3_signed_zero() { TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity), rcp(double3(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] [WindowsOnly("Mono on linux ignores signed zero.")] public static void rcp_double4_signed_zero() { TestUtils.AreEqual(double4(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double4(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] unsafe public static void compress_test() { int4 value = int4(0x12345678, 0x2468ACE0, 0x369BE147, 0x48C059D1); @@ -3250,7 +3250,7 @@ unsafe public static void compress_test() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] unsafe public static void compress_uint4_test() { uint4 value = uint4(0x12345678u, 0x2468ACE0u, 0x369BE147u, 0x48C059D1u); @@ -3296,7 +3296,7 @@ unsafe public static void compress_uint4_test() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] unsafe public static void compress_float4_test() { float4 value = float4(float.PositiveInfinity, EPSILON, PI, -0.25f); @@ -3342,7 +3342,7 @@ unsafe public static void compress_float4_test() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_float() { TestUtils.AreEqual(0.0f, math.square(0.0f)); @@ -3370,7 +3370,7 @@ public static void square_float() TestUtils.AreEqual(float.PositiveInfinity, math.square(-18446744073709551616.0f)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_float2() { TestUtils.AreEqual(new float2(0.0f), math.square(new float2(0.0f))); @@ -3401,7 +3401,7 @@ public static void square_float2() TestUtils.AreEqual(new float2(0.272176146507263183594f, 96307.6015625f), math.square(new float2(0.521705031394958496094f, -310.33465576171875f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_float3() { TestUtils.AreEqual(new float3(0.0f), math.square(new float3(0.0f))); @@ -3432,7 +3432,7 @@ public static void square_float3() TestUtils.AreEqual(new float3(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f), math.square(new float3(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_float4() { TestUtils.AreEqual(new float4(0.0f), math.square(new float4(0.0f))); @@ -3463,7 +3463,7 @@ public static void square_float4() TestUtils.AreEqual(new float4(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f, 152764.28125f), math.square(new float4(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f, 390.8507080078125f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_double() { TestUtils.AreEqual(0.0, math.square(0.0)); @@ -3491,7 +3491,7 @@ public static void square_double() TestUtils.AreEqual(double.PositiveInfinity, math.square(-1.34078079299425970996e+154)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_double2() { TestUtils.AreEqual(new double2(0.0), math.square(new double2(0.0))); @@ -3522,7 +3522,7 @@ public static void square_double2() TestUtils.AreEqual(new double2(0.272176139782814630053, 96307.5985667444765568), math.square(new double2(0.521705031394958496094, -310.33465576171875))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_double3() { TestUtils.AreEqual(new double3(0.0), math.square(new double3(0.0))); @@ -3553,7 +3553,7 @@ public static void square_double3() TestUtils.AreEqual(new double3(0.272176139782814630053, 96307.5985667444765568, 5591.63402314303675666), math.square(new double3(0.521705031394958496094, -310.33465576171875, -74.77722930908203125))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_double4() { TestUtils.AreEqual(new double4(0.0), math.square(new double4(0.0))); @@ -3584,7 +3584,7 @@ public static void square_double4() TestUtils.AreEqual(new double4(0.272176139782814630053, 96307.5985667444765568 /*96307.5985667444765568*/, 5591.63402314303675666 /*5591.6337890625*/, 152764.275950208306313 /*152764.28125*/), math.square(new double4(0.521705031394958496094, -310.33465576171875, -74.77722930908203125, 390.8507080078125))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_int() { TestUtils.AreEqual(0, math.square(0)); @@ -3612,7 +3612,7 @@ public static void square_int() TestUtils.AreEqual(0, math.square(-2147483648)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_int2() { TestUtils.AreEqual(new int2(0), math.square(new int2(0))); @@ -3643,7 +3643,7 @@ public static void square_int2() TestUtils.AreEqual(new int2(2121580241, -685235535), math.square(new int2(-831443639, 1415191751))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_int3() { TestUtils.AreEqual(new int3(0), math.square(new int3(0))); @@ -3674,7 +3674,7 @@ public static void square_int3() TestUtils.AreEqual(new int3(2121580241, -685235535, 468048505), math.square(new int3(-831443639, 1415191751, -178100469))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_int4() { TestUtils.AreEqual(new int4(0), math.square(new int4(0))); @@ -3705,7 +3705,7 @@ public static void square_int4() TestUtils.AreEqual(new int4(2121580241, -685235535, 468048505, -1902728316), math.square(new int4(-831443639, 1415191751, -178100469, 1331775970))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_uint() { TestUtils.AreEqual(0u, math.square(0u)); @@ -3723,7 +3723,7 @@ public static void square_uint() TestUtils.AreEqual(2356482048u, math.square(123456u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_uint2() { TestUtils.AreEqual(new uint2(0u), math.square(new uint2(0u))); @@ -3744,7 +3744,7 @@ public static void square_uint2() TestUtils.AreEqual(new uint2(3982663844u, 503153673u), math.square(new uint2(779359642u, 2488899075u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_uint3() { TestUtils.AreEqual(new uint3(0u), math.square(new uint3(0u))); @@ -3765,7 +3765,7 @@ public static void square_uint3() TestUtils.AreEqual(new uint3(3982663844u, 503153673u, 4101817232u), math.square(new uint3(779359642u, 2488899075u, 407772844u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void square_uint4() { TestUtils.AreEqual(new uint4(0u), math.square(new uint4(0u))); @@ -3809,7 +3809,7 @@ static double OrthonormalBasisSquaredError(double3 v1, double3 v2, double3 v3) // "Building an Orthonormal Basis, Revisited" table 1. private const double kOrthonormalBasisSqErrorTolerance = 1.04e-7d; - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void orthonormal_basis_float() { var random = new Random(8189782u); @@ -3824,7 +3824,7 @@ public static void orthonormal_basis_float() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void orthonormal_basis_double() { var random = new Random(99917872u); @@ -3839,7 +3839,7 @@ public static void orthonormal_basis_double() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void chgsign_float() { float c = chgsign(1f, -1f); @@ -3901,7 +3901,7 @@ public static void chgsign_float() TestUtils.AreEqual(asuint(TestUtils.SignedFloatZero()), asuint(c)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void chgsign_float2() { float2 c = chgsign(float2(1f, -2f), float2(-1f, 23.548f)); @@ -3936,7 +3936,7 @@ public static void chgsign_float2() TestUtils.AreEqual(asuint(math.float2(TestUtils.SignedFloatZero())), asuint(c)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void chgsign_float3() { float3 c = chgsign(float3(1f, -2f, 3f), float3(-1f, 23.548f, -0f)); @@ -3971,7 +3971,7 @@ public static void chgsign_float3() TestUtils.AreEqual(asuint(math.float3(TestUtils.SignedFloatZero())), asuint(c)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void chgsign_float4() { float4 c = chgsign(float4(1f, 2f, 3f, -4f), float4(-1f, 0f, -0f, -23.56f)); @@ -4006,7 +4006,7 @@ public static void chgsign_float4() TestUtils.AreEqual(asuint(math.float4(TestUtils.SignedFloatZero())), asuint(c)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static unsafe void quaternion_to_euler() { const float epsilon = 0.0045f; @@ -4079,7 +4079,7 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order) } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mulScale() { var tolerance = 1e-5f; @@ -4101,7 +4101,7 @@ public static void mulScale() TestUtils.AreEqual(expected, actual, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void scaleMul() { var tolerance = 1e-5f; @@ -4123,7 +4123,7 @@ public static void scaleMul() TestUtils.AreEqual(expected, actual, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void piDoubleConstants() { var expectedPi = 3.141592653589793116; @@ -4133,7 +4133,7 @@ public static void piDoubleConstants() TestUtils.AreEqual(expectedPi * 2.0, TAU_DBL); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void piSingleConstants() { var expectedPi = 3.141592653589793116f; @@ -4143,7 +4143,7 @@ public static void piSingleConstants() TestUtils.AreEqual(expectedPi * 2.0f, TAU); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void toDegreesConstants() { TestUtils.AreEqual(360.0, PI2_DBL * TODEGREES_DBL); @@ -4157,7 +4157,7 @@ public static void toDegreesConstants() TestUtils.AreEqual(90.0f, PIHALF * TODEGREES); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void toRadiansConstants() { TestUtils.AreEqual(PI2_DBL, 360.0 * TORADIANS_DBL); @@ -4171,7 +4171,7 @@ public static void toRadiansConstants() TestUtils.AreEqual(PIHALF, 90.0f * TORADIANS); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degreesConversionGivesSameResult() { int n = 360; @@ -4184,7 +4184,7 @@ public static void degreesConversionGivesSameResult() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radiansConversionGivesSameResult() { int n = 360; diff --git a/src/Tests/Tests/Shared/TestMath.gen.cs b/src/Tests/Tests/Shared/TestMath.gen.cs index 1a8e3253..3a803b97 100644 --- a/src/Tests/Tests/Shared/TestMath.gen.cs +++ b/src/Tests/Tests/Shared/TestMath.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestMath { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_int() { TestUtils.AreEqual(0, abs(0)); @@ -25,7 +25,7 @@ public static void abs_int() TestUtils.AreEqual(-2147483648, abs(-2147483648)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_int2() { TestUtils.AreEqual(int2(0, 7), abs(int2(0, -7))); @@ -33,21 +33,21 @@ public static void abs_int2() TestUtils.AreEqual(int2(-2147483648, -2147483648), abs(int2(-2147483648, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_int3() { TestUtils.AreEqual(int3(0, 7, 11), abs(int3(0, -7, 11))); TestUtils.AreEqual(int3(2147483647, -2147483648, -2147483648), abs(int3(-2147483647, -2147483648, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_int4() { TestUtils.AreEqual(int4(0, 7, 11, 2147483647), abs(int4(0, -7, 11, -2147483647))); TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -2147483648), abs(int4(-2147483648, -2147483648, -2147483648, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_float() { TestUtils.AreEqual(0f, abs(0f)); @@ -57,7 +57,7 @@ public static void abs_float() TestUtils.AreEqual(float.PositiveInfinity, abs(float.PositiveInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_float2() { TestUtils.AreEqual(float2(0f, 1.1f), abs(float2(0f, -1.1f))); @@ -65,21 +65,21 @@ public static void abs_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), abs(float2(float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_float3() { TestUtils.AreEqual(float3(0f, 1.1f, 2.2f), abs(float3(0f, -1.1f, 2.2f))); TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_float4() { TestUtils.AreEqual(float4(0f, 1.1f, 2.2f, float.PositiveInfinity), abs(float4(0f, -1.1f, 2.2f, float.NegativeInfinity))); TestUtils.AreEqual(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_double() { TestUtils.AreEqual(0.0, abs(0.0)); @@ -89,7 +89,7 @@ public static void abs_double() TestUtils.AreEqual(double.PositiveInfinity, abs(double.PositiveInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_double2() { TestUtils.AreEqual(double2(0.0, 1.1), abs(double2(0.0, -1.1))); @@ -97,21 +97,21 @@ public static void abs_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), abs(double2(double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_double3() { TestUtils.AreEqual(double3(0.0, 1.1, 2.2), abs(double3(0.0, -1.1, 2.2))); TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void abs_double4() { TestUtils.AreEqual(double4(0.0, 1.1, 2.2, double.PositiveInfinity), abs(double4(0.0, -1.1, 2.2, double.NegativeInfinity))); TestUtils.AreEqual(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_float() { TestUtils.AreEqual(false, isfinite(TestUtils.SignedFloatQNaN())); @@ -125,7 +125,7 @@ public static void isfinite_float() TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_float2() { TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity))); @@ -135,7 +135,7 @@ public static void isfinite_float2() TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_float3() { TestUtils.AreEqual(bool3(false, false, true), isfinite(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue))); @@ -143,7 +143,7 @@ public static void isfinite_float3() TestUtils.AreEqual(bool3(true, false, false), isfinite(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_float4() { TestUtils.AreEqual(bool4(false, false, true, true), isfinite(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f))); @@ -151,7 +151,7 @@ public static void isfinite_float4() TestUtils.AreEqual(bool4(false, false, false, false), isfinite(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_double() { TestUtils.AreEqual(false, isfinite(TestUtils.SignedDoubleQNaN())); @@ -165,7 +165,7 @@ public static void isfinite_double() TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_double2() { TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity))); @@ -175,7 +175,7 @@ public static void isfinite_double2() TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_double3() { TestUtils.AreEqual(bool3(false, false, true), isfinite(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue))); @@ -183,7 +183,7 @@ public static void isfinite_double3() TestUtils.AreEqual(bool3(true, false, false), isfinite(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isfinite_double4() { TestUtils.AreEqual(bool4(false, false, true, true), isfinite(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0))); @@ -191,7 +191,7 @@ public static void isfinite_double4() TestUtils.AreEqual(bool4(false, false, false, false), isfinite(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_float() { TestUtils.AreEqual(false, isinf(TestUtils.SignedFloatQNaN())); @@ -205,7 +205,7 @@ public static void isinf_float() TestUtils.AreEqual(false, isinf(TestUtils.UnsignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_float2() { TestUtils.AreEqual(bool2(false, true), isinf(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity))); @@ -215,7 +215,7 @@ public static void isinf_float2() TestUtils.AreEqual(bool2(false, false), isinf(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_float3() { TestUtils.AreEqual(bool3(false, true, false), isinf(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue))); @@ -223,7 +223,7 @@ public static void isinf_float3() TestUtils.AreEqual(bool3(false, true, false), isinf(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_float4() { TestUtils.AreEqual(bool4(false, true, false, false), isinf(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f))); @@ -231,7 +231,7 @@ public static void isinf_float4() TestUtils.AreEqual(bool4(false, false, false, false), isinf(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_double() { TestUtils.AreEqual(false, isinf(TestUtils.SignedDoubleQNaN())); @@ -245,7 +245,7 @@ public static void isinf_double() TestUtils.AreEqual(false, isinf(TestUtils.UnsignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_double2() { TestUtils.AreEqual(bool2(false, true), isinf(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity))); @@ -255,7 +255,7 @@ public static void isinf_double2() TestUtils.AreEqual(bool2(false, false), isinf(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_double3() { TestUtils.AreEqual(bool3(false, true, false), isinf(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue))); @@ -263,7 +263,7 @@ public static void isinf_double3() TestUtils.AreEqual(bool3(false, true, false), isinf(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isinf_double4() { TestUtils.AreEqual(bool4(false, true, false, false), isinf(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0))); @@ -271,7 +271,7 @@ public static void isinf_double4() TestUtils.AreEqual(bool4(false, false, false, false), isinf(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_float() { TestUtils.AreEqual(true, isnan(TestUtils.SignedFloatQNaN())); @@ -285,7 +285,7 @@ public static void isnan_float() TestUtils.AreEqual(true, isnan(TestUtils.UnsignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_float2() { TestUtils.AreEqual(bool2(true, false), isnan(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity))); @@ -295,7 +295,7 @@ public static void isnan_float2() TestUtils.AreEqual(bool2(true, true), isnan(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_float3() { TestUtils.AreEqual(bool3(true, false, false), isnan(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue))); @@ -303,7 +303,7 @@ public static void isnan_float3() TestUtils.AreEqual(bool3(false, false, true), isnan(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_float4() { TestUtils.AreEqual(bool4(true, false, false, false), isnan(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f))); @@ -311,7 +311,7 @@ public static void isnan_float4() TestUtils.AreEqual(bool4(true, true, true, true), isnan(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_double() { TestUtils.AreEqual(true, isnan(TestUtils.SignedDoubleQNaN())); @@ -325,7 +325,7 @@ public static void isnan_double() TestUtils.AreEqual(true, isnan(TestUtils.UnsignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_double2() { TestUtils.AreEqual(bool2(true, false), isnan(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity))); @@ -335,7 +335,7 @@ public static void isnan_double2() TestUtils.AreEqual(bool2(true, true), isnan(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_double3() { TestUtils.AreEqual(bool3(true, false, false), isnan(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue))); @@ -343,7 +343,7 @@ public static void isnan_double3() TestUtils.AreEqual(bool3(false, false, true), isnan(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void isnan_double4() { TestUtils.AreEqual(bool4(true, false, false, false), isnan(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0))); @@ -351,7 +351,7 @@ public static void isnan_double4() TestUtils.AreEqual(bool4(true, true, true, true), isnan(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_float() { TestUtils.AreEqual(0.3499935f, sin(-1000000f), 1, false); @@ -364,7 +364,7 @@ public static void sin_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sin(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_float2() { TestUtils.AreEqual(float2(0.3499935f, -0.9320391f), sin(float2(-1000000f, -1.2f)), 1, false); @@ -373,7 +373,7 @@ public static void sin_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_float3() { TestUtils.AreEqual(float3(0.3499935f, -0.9320391f, 0f), sin(float3(-1000000f, -1.2f, 0f)), 1, false); @@ -381,14 +381,14 @@ public static void sin_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_float4() { TestUtils.AreEqual(float4(0.3499935f, -0.9320391f, 0f, 0.9320391f), sin(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(-0.3499935f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_double() { TestUtils.AreEqual(0.34999350217129294, sin(-1000000.0), 32, false); @@ -401,7 +401,7 @@ public static void sin_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sin(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_double2() { TestUtils.AreEqual(double2(0.34999350217129294, -0.9320390859672264), sin(double2(-1000000.0, -1.2)), 32, false); @@ -410,7 +410,7 @@ public static void sin_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_double3() { TestUtils.AreEqual(double3(0.34999350217129294, -0.9320390859672264, 0.0), sin(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -418,14 +418,14 @@ public static void sin_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sin_double4() { TestUtils.AreEqual(double4(0.34999350217129294, -0.9320390859672264, 0.0, 0.9320390859672264), sin(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(-0.34999350217129294, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_float() { TestUtils.AreEqual(0.936752141f, cos(-1000000f), 8, false); @@ -438,7 +438,7 @@ public static void cos_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), cos(float.PositiveInfinity), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_float2() { TestUtils.AreEqual(float2(0.936752141f, 0.362357765f), cos(float2(-1000000f, -1.2f)), 8, false); @@ -447,7 +447,7 @@ public static void cos_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_float3() { TestUtils.AreEqual(float3(0.936752141f, 0.362357765f, 1f), cos(float3(-1000000f, -1.2f, 0f)), 8, false); @@ -455,14 +455,14 @@ public static void cos_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_float4() { TestUtils.AreEqual(float4(0.936752141f, 0.362357765f, 1f, 0.362357765f), cos(float4(-1000000f, -1.2f, 0f, 1.2f)), 8, false); TestUtils.AreEqual(float4(0.936752141f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_double() { TestUtils.AreEqual(0.93675212753314474, cos(-1000000.0), 32, false); @@ -475,7 +475,7 @@ public static void cos_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), cos(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_double2() { TestUtils.AreEqual(double2(0.93675212753314474, 0.36235775447667357), cos(double2(-1000000.0, -1.2)), 32, false); @@ -484,7 +484,7 @@ public static void cos_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_double3() { TestUtils.AreEqual(double3(0.93675212753314474, 0.36235775447667357, 1.0), cos(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -492,14 +492,14 @@ public static void cos_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cos_double4() { TestUtils.AreEqual(double4(0.93675212753314474, 0.36235775447667357, 1.0, 0.36235775447667357), cos(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.93675212753314474, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_float() { TestUtils.AreEqual(0.373624444f, tan(-1000000f), 1, false); @@ -512,7 +512,7 @@ public static void tan_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), tan(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_float2() { TestUtils.AreEqual(float2(0.373624444f, -2.57215166f), tan(float2(-1000000f, -1.2f)), 1, false); @@ -521,7 +521,7 @@ public static void tan_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_float3() { TestUtils.AreEqual(float3(0.373624444f, -2.57215166f, 0f), tan(float3(-1000000f, -1.2f, 0f)), 1, false); @@ -529,14 +529,14 @@ public static void tan_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_float4() { TestUtils.AreEqual(float4(0.373624444f, -2.57215166f, 0f, 2.57215166f), tan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(-0.373624444f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_double() { TestUtils.AreEqual(0.373624453987599, tan(-1000000.0), 32, false); @@ -549,7 +549,7 @@ public static void tan_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), tan(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_double2() { TestUtils.AreEqual(double2(0.373624453987599, -2.57215162212632), tan(double2(-1000000.0, -1.2)), 32, false); @@ -558,7 +558,7 @@ public static void tan_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_double3() { TestUtils.AreEqual(double3(0.373624453987599, -2.57215162212632, 0.0), tan(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -566,14 +566,14 @@ public static void tan_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tan_double4() { TestUtils.AreEqual(double4(0.373624453987599, -2.57215162212632, 0.0, 2.57215162212632), tan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(-0.373624453987599, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_float() { TestUtils.AreEqual(-1.5707953f, atan(-1000000f), 1, false); @@ -586,7 +586,7 @@ public static void atan_float() TestUtils.AreEqual(1.57079637f, atan(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_float2() { TestUtils.AreEqual(float2(-1.5707953f, -0.876058042f), atan(float2(-1000000f, -1.2f)), 1, false); @@ -595,7 +595,7 @@ public static void atan_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_float3() { TestUtils.AreEqual(float3(-1.5707953f, -0.876058042f, 0f), atan(float3(-1000000f, -1.2f, 0f)), 1, false); @@ -603,14 +603,14 @@ public static void atan_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1.57079637f, 1.57079637f), atan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_float4() { TestUtils.AreEqual(float4(-1.5707953f, -0.876058042f, 0f, 0.876058042f), atan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(1.5707953f, -1.57079637f, TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_double() { TestUtils.AreEqual(-1.5707953267948971, atan(-1000000.0), 32, false); @@ -623,7 +623,7 @@ public static void atan_double() TestUtils.AreEqual(1.570796326794897, atan(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_double2() { TestUtils.AreEqual(double2(-1.5707953267948971, -0.87605805059819342), atan(double2(-1000000.0, -1.2)), 32, false); @@ -632,7 +632,7 @@ public static void atan_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_double3() { TestUtils.AreEqual(double3(-1.5707953267948971, -0.87605805059819342, 0.0), atan(double3(-1000000.0, -1.2, 0.0)), 32, false); @@ -640,14 +640,14 @@ public static void atan_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.570796326794897, 1.570796326794897), atan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan_double4() { TestUtils.AreEqual(double4(-1.5707953267948971, -0.87605805059819342, 0.0, 0.87605805059819342), atan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(1.5707953267948971, -1.570796326794897, TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_float() { TestUtils.AreEqual(0.9119903f, atan2(3.1f, 2.4f), 1, false); @@ -664,7 +664,7 @@ public static void atan2_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), atan2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_float2() { TestUtils.AreEqual(float2(0.9119903f, 2.22960234f), atan2(float2(3.1f, 3.1f), float2(2.4f, -2.4f)), 1, false); @@ -675,7 +675,7 @@ public static void atan2_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(1f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_float3() { TestUtils.AreEqual(float3(0.9119903f, 2.22960234f, -0.9119903f), atan2(float3(3.1f, 3.1f, -3.1f), float3(2.4f, -2.4f, 2.4f)), 1, false); @@ -684,7 +684,7 @@ public static void atan2_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float3(1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_float4() { TestUtils.AreEqual(float4(0.9119903f, 2.22960234f, -0.9119903f, -2.22960234f), atan2(float4(3.1f, 3.1f, -3.1f, -3.1f), float4(2.4f, -2.4f, 2.4f, -2.4f)), 1, false); @@ -692,7 +692,7 @@ public static void atan2_float4() TestUtils.AreEqual(float4(1.57079637f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float4(float.PositiveInfinity, 1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(1f, TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_double() { TestUtils.AreEqual(0.91199029067742043, atan2(3.1, 2.4), 32, false); @@ -709,7 +709,7 @@ public static void atan2_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), atan2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_double2() { TestUtils.AreEqual(double2(0.91199029067742043, 2.2296023629123729), atan2(double2(3.1, 3.1), double2(2.4, -2.4)), 32, false); @@ -720,7 +720,7 @@ public static void atan2_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(1.0, TestUtils.SignedDoubleQNaN())), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_double3() { TestUtils.AreEqual(double3(0.91199029067742043, 2.2296023629123729, -0.91199029067742043), atan2(double3(3.1, 3.1, -3.1), double3(2.4, -2.4, 2.4)), 32, false); @@ -729,7 +729,7 @@ public static void atan2_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double3(1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void atan2_double4() { TestUtils.AreEqual(double4(0.91199029067742043, 2.2296023629123729, -0.91199029067742043, -2.2296023629123729), atan2(double4(3.1, 3.1, -3.1, -3.1), double4(2.4, -2.4, 2.4, -2.4)), 32, false); @@ -737,7 +737,7 @@ public static void atan2_double4() TestUtils.AreEqual(double4(1.5707963267948966, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double4(double.PositiveInfinity, 1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(1.0, TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_float() { TestUtils.AreEqual(-3.62686038f, sinh(-2f), 1, false); @@ -750,7 +750,7 @@ public static void sinh_float() TestUtils.AreEqual(float.PositiveInfinity, sinh(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_float2() { TestUtils.AreEqual(float2(-3.62686038f, -1.5094614f), sinh(float2(-2f, -1.2f)), 1, false); @@ -759,7 +759,7 @@ public static void sinh_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_float3() { TestUtils.AreEqual(float3(-3.62686038f, -1.5094614f, 0f), sinh(float3(-2f, -1.2f, 0f)), 1, false); @@ -767,14 +767,14 @@ public static void sinh_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sinh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_float4() { TestUtils.AreEqual(float4(-3.62686038f, -1.5094614f, 0f, 1.5094614f), sinh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(3.62686038f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_double() { TestUtils.AreEqual(-3.6268604078470181, sinh(-2.0), 32, false); @@ -787,7 +787,7 @@ public static void sinh_double() TestUtils.AreEqual(double.PositiveInfinity, sinh(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_double2() { TestUtils.AreEqual(double2(-3.6268604078470181, -1.509461355412173), sinh(double2(-2.0, -1.2)), 32, false); @@ -796,7 +796,7 @@ public static void sinh_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_double3() { TestUtils.AreEqual(double3(-3.6268604078470181, -1.509461355412173, 0.0), sinh(double3(-2.0, -1.2, 0.0)), 32, false); @@ -804,14 +804,14 @@ public static void sinh_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sinh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sinh_double4() { TestUtils.AreEqual(double4(-3.6268604078470181, -1.509461355412173, 0.0, 1.509461355412173), sinh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(3.6268604078470181, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_float() { TestUtils.AreEqual(3.76219559f, cosh(-2f), 1, false); @@ -824,7 +824,7 @@ public static void cosh_float() TestUtils.AreEqual(float.PositiveInfinity, cosh(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_float2() { TestUtils.AreEqual(float2(3.76219559f, 1.81065559f), cosh(float2(-2f, -1.2f)), 1, false); @@ -833,7 +833,7 @@ public static void cosh_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_float3() { TestUtils.AreEqual(float3(3.76219559f, 1.81065559f, 1f), cosh(float3(-2f, -1.2f, 0f)), 1, false); @@ -841,14 +841,14 @@ public static void cosh_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), cosh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_float4() { TestUtils.AreEqual(float4(3.76219559f, 1.81065559f, 1f, 1.81065559f), cosh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(3.76219559f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_double() { TestUtils.AreEqual(3.7621956910836314, cosh(-2.0), 32, false); @@ -861,7 +861,7 @@ public static void cosh_double() TestUtils.AreEqual(double.PositiveInfinity, cosh(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_double2() { TestUtils.AreEqual(double2(3.7621956910836314, 1.81065556732437), cosh(double2(-2.0, -1.2)), 32, false); @@ -870,7 +870,7 @@ public static void cosh_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_double3() { TestUtils.AreEqual(double3(3.7621956910836314, 1.81065556732437, 1.0), cosh(double3(-2.0, -1.2, 0.0)), 32, false); @@ -878,14 +878,14 @@ public static void cosh_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), cosh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void cosh_double4() { TestUtils.AreEqual(double4(3.7621956910836314, 1.81065556732437, 1.0, 1.81065556732437), cosh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(3.7621956910836314, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_float() { TestUtils.AreEqual(-0.9640276f, tanh(-2f), 1, false); @@ -898,7 +898,7 @@ public static void tanh_float() TestUtils.AreEqual(1f, tanh(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_float2() { TestUtils.AreEqual(float2(-0.9640276f, -0.8336546f), tanh(float2(-2f, -1.2f)), 1, false); @@ -907,7 +907,7 @@ public static void tanh_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1f), tanh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_float3() { TestUtils.AreEqual(float3(-0.9640276f, -0.8336546f, 0f), tanh(float3(-2f, -1.2f, 0f)), 1, false); @@ -915,14 +915,14 @@ public static void tanh_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1f, 1f), tanh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_float4() { TestUtils.AreEqual(float4(-0.9640276f, -0.8336546f, 0f, 0.8336546f), tanh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(0.9640276f, -1f, TestUtils.SignedFloatQNaN(), 1f), tanh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_double() { TestUtils.AreEqual(-0.9640275800758169, tanh(-2.0), 32, false); @@ -935,7 +935,7 @@ public static void tanh_double() TestUtils.AreEqual(1.0, tanh(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_double2() { TestUtils.AreEqual(double2(-0.9640275800758169, -0.83365460701215521), tanh(double2(-2.0, -1.2)), 32, false); @@ -944,7 +944,7 @@ public static void tanh_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.0), tanh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_double3() { TestUtils.AreEqual(double3(-0.9640275800758169, -0.83365460701215521, 0.0), tanh(double3(-2.0, -1.2, 0.0)), 32, false); @@ -952,14 +952,14 @@ public static void tanh_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.0, 1.0), tanh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void tanh_double4() { TestUtils.AreEqual(double4(-0.9640275800758169, -0.83365460701215521, 0.0, 0.83365460701215521), tanh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.9640275800758169, -1.0, TestUtils.SignedDoubleQNaN(), 1.0), tanh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_float() { TestUtils.AreEqual(4.539993E-05f, exp(-10f), 1, false); @@ -971,7 +971,7 @@ public static void exp_float() TestUtils.AreEqual(float.PositiveInfinity, exp(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_float2() { TestUtils.AreEqual(float2(4.539993E-05f, 0.301194221f), exp(float2(-10f, -1.2f)), 1, false); @@ -980,7 +980,7 @@ public static void exp_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_float3() { TestUtils.AreEqual(float3(4.539993E-05f, 0.301194221f, 1f), exp(float3(-10f, -1.2f, 0f)), 1, false); @@ -988,14 +988,14 @@ public static void exp_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_float4() { TestUtils.AreEqual(float4(4.539993E-05f, 0.301194221f, 1f, 3.320117f), exp(float4(-10f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_double() { TestUtils.AreEqual(4.5399929762484847E-05, exp(-10.0), 32, false); @@ -1007,7 +1007,7 @@ public static void exp_double() TestUtils.AreEqual(double.PositiveInfinity, exp(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_double2() { TestUtils.AreEqual(double2(4.5399929762484847E-05, 0.30119421191220208), exp(double2(-10.0, -1.2)), 32, false); @@ -1016,7 +1016,7 @@ public static void exp_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_double3() { TestUtils.AreEqual(double3(4.5399929762484847E-05, 0.30119421191220208, 1.0), exp(double3(-10.0, -1.2, 0.0)), 32, false); @@ -1024,14 +1024,14 @@ public static void exp_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp_double4() { TestUtils.AreEqual(double4(4.5399929762484847E-05, 0.30119421191220208, 1.0, 3.3201169227365477), exp(double4(-10.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_float() { TestUtils.AreEqual(0.0009765625f, exp2(-10f), 1, false); @@ -1043,7 +1043,7 @@ public static void exp2_float() TestUtils.AreEqual(float.PositiveInfinity, exp2(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_float2() { TestUtils.AreEqual(float2(0.0009765625f, 0.4352753f), exp2(float2(-10f, -1.2f)), 1, false); @@ -1052,7 +1052,7 @@ public static void exp2_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_float3() { TestUtils.AreEqual(float3(0.0009765625f, 0.4352753f, 1f), exp2(float3(-10f, -1.2f, 0f)), 1, false); @@ -1060,14 +1060,14 @@ public static void exp2_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_float4() { TestUtils.AreEqual(float4(0.0009765625f, 0.4352753f, 1f, 2.29739666f), exp2(float4(-10f, -1.2f, 0f, 1.2f)), 1, false); TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_double() { TestUtils.AreEqual(0.0009765625, exp2(-10.0), 32, false); @@ -1079,7 +1079,7 @@ public static void exp2_double() TestUtils.AreEqual(double.PositiveInfinity, exp2(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_double2() { TestUtils.AreEqual(double2(0.0009765625, 0.435275281648062), exp2(double2(-10.0, -1.2)), 32, false); @@ -1088,7 +1088,7 @@ public static void exp2_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_double3() { TestUtils.AreEqual(double3(0.0009765625, 0.435275281648062, 1.0), exp2(double3(-10.0, -1.2, 0.0)), 32, false); @@ -1096,14 +1096,14 @@ public static void exp2_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp2_double4() { TestUtils.AreEqual(double4(0.0009765625, 0.435275281648062, 1.0, 2.29739670999407), exp2(double4(-10.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_float() { TestUtils.AreEqual(1E-10f, exp10(-10f), 32, false); @@ -1115,7 +1115,7 @@ public static void exp10_float() TestUtils.AreEqual(float.PositiveInfinity, exp10(float.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_float2() { TestUtils.AreEqual(float2(1E-10f, 0.06309573f), exp10(float2(-10f, -1.2f)), 32, false); @@ -1124,7 +1124,7 @@ public static void exp10_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp10(float2(float.PositiveInfinity, float.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_float3() { TestUtils.AreEqual(float3(1E-10f, 0.06309573f, 1f), exp10(float3(-10f, -1.2f, 0f)), 32, false); @@ -1132,14 +1132,14 @@ public static void exp10_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_float4() { TestUtils.AreEqual(float4(1E-10f, 0.06309573f, 1f, 15.8489323f), exp10(float4(-10f, -1.2f, 0f, 1.2f)), 32, false); TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_double() { TestUtils.AreEqual(1E-10, exp10(-10.0), 32, false); @@ -1151,7 +1151,7 @@ public static void exp10_double() TestUtils.AreEqual(double.PositiveInfinity, exp10(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_double2() { TestUtils.AreEqual(double2(1E-10, 0.063095734448019331), exp10(double2(-10.0, -1.2)), 32, false); @@ -1160,7 +1160,7 @@ public static void exp10_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_double3() { TestUtils.AreEqual(double3(1E-10, 0.063095734448019331, 1.0), exp10(double3(-10.0, -1.2, 0.0)), 32, false); @@ -1168,14 +1168,14 @@ public static void exp10_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void exp10_double4() { TestUtils.AreEqual(double4(1E-10, 0.063095734448019331, 1.0, 15.848931924611135), exp10(double4(-10.0, -1.2, 0.0, 1.2)), 32, false); TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_float() { TestUtils.AreEqual(-20.5409451f, log(1.2E-09f), 1, false); @@ -1187,7 +1187,7 @@ public static void log_float() TestUtils.AreEqual(float.PositiveInfinity, log(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_float2() { TestUtils.AreEqual(float2(-20.5409451f, 0f), log(float2(1.2E-09f, 1f)), 1, false); @@ -1196,7 +1196,7 @@ public static void log_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_float3() { TestUtils.AreEqual(float3(-20.5409451f, 0f, 23.2081718f), log(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false); @@ -1204,14 +1204,14 @@ public static void log_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_float4() { TestUtils.AreEqual(float4(-20.5409451f, 0f, 23.2081718f, TestUtils.SignedFloatQNaN()), log(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_double() { TestUtils.AreEqual(-20.540944280152456, log(1.2E-09), 32, false); @@ -1223,7 +1223,7 @@ public static void log_double() TestUtils.AreEqual(double.PositiveInfinity, log(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_double2() { TestUtils.AreEqual(double2(-20.540944280152456, 0.0), log(double2(1.2E-09, 1.0)), 32, false); @@ -1232,7 +1232,7 @@ public static void log_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_double3() { TestUtils.AreEqual(double3(-20.540944280152456, 0.0, 23.208172486734409), log(double3(1.2E-09, 1.0, 12000000000.0)), 32, false); @@ -1240,14 +1240,14 @@ public static void log_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log_double4() { TestUtils.AreEqual(double4(-20.540944280152456, 0.0, 23.208172486734409, TestUtils.SignedDoubleQNaN()), log(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_float() { TestUtils.AreEqual(-29.63432f, log2(1.2E-09f), 1, false); @@ -1259,7 +1259,7 @@ public static void log2_float() TestUtils.AreEqual(float.PositiveInfinity, log2(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_float2() { TestUtils.AreEqual(float2(-29.63432f, 0f), log2(float2(1.2E-09f, 1f)), 1, false); @@ -1268,7 +1268,7 @@ public static void log2_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_float3() { TestUtils.AreEqual(float3(-29.63432f, 0f, 33.4823151f), log2(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false); @@ -1276,14 +1276,14 @@ public static void log2_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_float4() { TestUtils.AreEqual(float4(-29.63432f, 0f, 33.4823151f, TestUtils.SignedFloatQNaN()), log2(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_double() { TestUtils.AreEqual(-29.634318448152467, log2(1.2E-09), 32, false); @@ -1295,7 +1295,7 @@ public static void log2_double() TestUtils.AreEqual(double.PositiveInfinity, log2(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_double2() { TestUtils.AreEqual(double2(-29.634318448152467, 0.0), log2(double2(1.2E-09, 1.0)), 32, false); @@ -1304,7 +1304,7 @@ public static void log2_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_double3() { TestUtils.AreEqual(double3(-29.634318448152467, 0.0, 33.482315354707417), log2(double3(1.2E-09, 1.0, 12000000000.0)), 32, false); @@ -1312,14 +1312,14 @@ public static void log2_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log2_double4() { TestUtils.AreEqual(double4(-29.634318448152467, 0.0, 33.482315354707417, TestUtils.SignedDoubleQNaN()), log2(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_float() { TestUtils.AreEqual(-8.920818f, log10(1.2E-09f), 1, false); @@ -1331,7 +1331,7 @@ public static void log10_float() TestUtils.AreEqual(float.PositiveInfinity, log10(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_float2() { TestUtils.AreEqual(float2(-8.920818f, 0f), log10(float2(1.2E-09f, 1f)), 1, false); @@ -1340,7 +1340,7 @@ public static void log10_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log10(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_float3() { TestUtils.AreEqual(float3(-8.920818f, 0f, 10.0791817f), log10(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false); @@ -1348,14 +1348,14 @@ public static void log10_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_float4() { TestUtils.AreEqual(float4(-8.920818f, 0f, 10.0791817f, TestUtils.SignedFloatQNaN()), log10(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_double() { TestUtils.AreEqual(-8.9208187539523749, log10(1.2E-09), 32, false); @@ -1367,7 +1367,7 @@ public static void log10_double() TestUtils.AreEqual(double.PositiveInfinity, log10(double.PositiveInfinity), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_double2() { TestUtils.AreEqual(double2(-8.9208187539523749, 0.0), log10(double2(1.2E-09, 1.0)), 32, false); @@ -1376,7 +1376,7 @@ public static void log10_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_double3() { TestUtils.AreEqual(double3(-8.9208187539523749, 0.0, 10.079181246047623), log10(double3(1.2E-09, 1.0, 12000000000.0)), 32, false); @@ -1384,14 +1384,14 @@ public static void log10_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void log10_double4() { TestUtils.AreEqual(double4(-8.9208187539523749, 0.0, 10.079181246047623, TestUtils.SignedDoubleQNaN()), log10(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_float() { TestUtils.AreEqual(-2.154609f, radians(-123.45f), 1, false); @@ -1402,7 +1402,7 @@ public static void radians_float() TestUtils.AreEqual(float.PositiveInfinity, radians(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_float2() { TestUtils.AreEqual(float2(-2.154609f, 0f), radians(float2(-123.45f, 0f)), 1, false); @@ -1410,21 +1410,21 @@ public static void radians_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_float3() { TestUtils.AreEqual(float3(-2.154609f, 0f, 2.154609f), radians(float3(-123.45f, 0f, 123.45f)), 1, false); TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_float4() { TestUtils.AreEqual(float4(-2.154609f, 0f, 2.154609f, float.NegativeInfinity), radians(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), radians(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_double() { TestUtils.AreEqual(-2.154608961587, radians(-123.45), 1, false); @@ -1435,7 +1435,7 @@ public static void radians_double() TestUtils.AreEqual(double.PositiveInfinity, radians(double.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_double2() { TestUtils.AreEqual(double2(-2.154608961587, 0.0), radians(double2(-123.45, 0.0)), 1, false); @@ -1443,21 +1443,21 @@ public static void radians_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_double3() { TestUtils.AreEqual(double3(-2.154608961587, 0.0, 2.154608961587), radians(double3(-123.45, 0.0, 123.45)), 1, false); TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void radians_double4() { TestUtils.AreEqual(double4(-2.154608961587, 0.0, 2.154608961587, double.NegativeInfinity), radians(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), radians(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_float() { TestUtils.AreEqual(-7073.164f, degrees(-123.45f), 1, false); @@ -1468,7 +1468,7 @@ public static void degrees_float() TestUtils.AreEqual(float.PositiveInfinity, degrees(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_float2() { TestUtils.AreEqual(float2(-7073.164f, 0f), degrees(float2(-123.45f, 0f)), 1, false); @@ -1476,21 +1476,21 @@ public static void degrees_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_float3() { TestUtils.AreEqual(float3(-7073.164f, 0f, 7073.164f), degrees(float3(-123.45f, 0f, 123.45f)), 1, false); TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_float4() { TestUtils.AreEqual(float4(-7073.164f, 0f, 7073.164f, float.NegativeInfinity), degrees(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), degrees(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_double() { TestUtils.AreEqual(-7073.1639808900127, degrees(-123.45), 1, false); @@ -1501,7 +1501,7 @@ public static void degrees_double() TestUtils.AreEqual(double.PositiveInfinity, degrees(double.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_double2() { TestUtils.AreEqual(double2(-7073.1639808900127, 0.0), degrees(double2(-123.45, 0.0)), 1, false); @@ -1509,21 +1509,21 @@ public static void degrees_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_double3() { TestUtils.AreEqual(double3(-7073.1639808900127, 0.0, 7073.1639808900127), degrees(double3(-123.45, 0.0, 123.45)), 1, false); TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void degrees_double4() { TestUtils.AreEqual(double4(-7073.1639808900127, 0.0, 7073.1639808900127, double.NegativeInfinity), degrees(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), degrees(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_int() { TestUtils.AreEqual(-1, sign(-156)); @@ -1540,7 +1540,7 @@ public static void sign_int() TestUtils.AreEqual(-1, sign(-2147483648)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_int2() { TestUtils.AreEqual(int2(-1, -1), sign(int2(-156, -214748346))); @@ -1551,7 +1551,7 @@ public static void sign_int2() TestUtils.AreEqual(int2(1, -1), sign(int2(2147483647, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_int3() { TestUtils.AreEqual(int3(-1, -1, 0), sign(int3(-156, -214748346, 0))); @@ -1560,7 +1560,7 @@ public static void sign_int3() TestUtils.AreEqual(int3(1, 1, -1), sign(int3(64583, 2147483647, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_int4() { TestUtils.AreEqual(int4(-1, -1, 0, 1), sign(int4(-156, -214748346, 0, 214748346))); @@ -1568,7 +1568,7 @@ public static void sign_int4() TestUtils.AreEqual(int4(-1, 1, 1, -1), sign(int4(-15379, 64583, 2147483647, -2147483648))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_float() { TestUtils.AreEqual(-1f, sign(-123.45f)); @@ -1581,7 +1581,7 @@ public static void sign_float() TestUtils.AreEqual(1f, sign(float.PositiveInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_float2() { TestUtils.AreEqual(float2(-1f, -1f), sign(float2(-123.45f, -1E-20f))); @@ -1590,7 +1590,7 @@ public static void sign_float2() TestUtils.AreEqual(float2(0f, 1f), sign(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_float3() { TestUtils.AreEqual(float3(-1f, -1f, 0f), sign(float3(-123.45f, -1E-20f, 0f))); @@ -1598,14 +1598,14 @@ public static void sign_float3() TestUtils.AreEqual(float3(0f, 1f, 1f), sign(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_float4() { TestUtils.AreEqual(float4(-1f, -1f, 0f, 1f), sign(float4(-123.45f, -1E-20f, 0f, 1E-10f))); TestUtils.AreEqual(float4(1f, -1f, 0f, 1f), sign(float4(123.45f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_double() { TestUtils.AreEqual(-1.0, sign(-123.45)); @@ -1618,7 +1618,7 @@ public static void sign_double() TestUtils.AreEqual(1.0, sign(double.PositiveInfinity)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_double2() { TestUtils.AreEqual(double2(-1.0, -1.0), sign(double2(-123.45, -1E-20))); @@ -1627,7 +1627,7 @@ public static void sign_double2() TestUtils.AreEqual(double2(0.0, 1.0), sign(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_double3() { TestUtils.AreEqual(double3(-1.0, -1.0, 0.0), sign(double3(-123.45, -1E-20, 0.0))); @@ -1635,14 +1635,14 @@ public static void sign_double3() TestUtils.AreEqual(double3(0.0, 1.0, 1.0), sign(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sign_double4() { TestUtils.AreEqual(double4(-1.0, -1.0, 0.0, 1.0), sign(double4(-123.45, -1E-20, 0.0, 1E-10))); TestUtils.AreEqual(double4(1.0, -1.0, 0.0, 1.0), sign(double4(123.45, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sqrt(-1f), 1, false); @@ -1654,7 +1654,7 @@ public static void sqrt_float() TestUtils.AreEqual(float.PositiveInfinity, sqrt(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), sqrt(float2(-1f, 0f)), 1, false); @@ -1663,7 +1663,7 @@ public static void sqrt_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), sqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 1E-05f), sqrt(float3(-1f, 0f, 1E-10f)), 1, false); @@ -1671,14 +1671,14 @@ public static void sqrt_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), sqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 1E-05f, 11.1108055f), sqrt(float4(-1f, 0f, 1E-10f, 123.45f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sqrt(-1.0), 1, false); @@ -1690,7 +1690,7 @@ public static void sqrt_double() TestUtils.AreEqual(double.PositiveInfinity, sqrt(double.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), sqrt(double2(-1.0, 0.0)), 1, false); @@ -1699,7 +1699,7 @@ public static void sqrt_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), sqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05), sqrt(double3(-1.0, 0.0, 1E-10)), 1, false); @@ -1707,14 +1707,14 @@ public static void sqrt_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), sqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void sqrt_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05, 11.11080555135405), sqrt(double4(-1.0, 0.0, 1E-10, 123.45)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), rsqrt(-1f), 1, false); @@ -1726,7 +1726,7 @@ public static void rsqrt_float() TestUtils.AreEqual(0f, rsqrt(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), rsqrt(float2(-1f, 0f)), 1, false); @@ -1735,7 +1735,7 @@ public static void rsqrt_float2() TestUtils.AreEqual(float2(0f, 0f), rsqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f), rsqrt(float3(-1f, 0f, 1E+10f)), 1, false); @@ -1743,14 +1743,14 @@ public static void rsqrt_float3() TestUtils.AreEqual(float3(0f, 0f, 0f), rsqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f, 0.09000248f), rsqrt(float4(-1f, 0f, 1E+10f, 123.45f)), 1, false); TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), 0f, 0f), rsqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), rsqrt(-1.0), 1, false); @@ -1762,7 +1762,7 @@ public static void rsqrt_double() TestUtils.AreEqual(0.0, rsqrt(double.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), rsqrt(double2(-1.0, 0.0)), 1, false); @@ -1771,7 +1771,7 @@ public static void rsqrt_double2() TestUtils.AreEqual(double2(0.0, 0.0), rsqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05), rsqrt(double3(-1.0, 0.0, 10000000000.0)), 1, false); @@ -1779,14 +1779,14 @@ public static void rsqrt_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), rsqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rsqrt_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05, 0.090002475102098425), rsqrt(double4(-1.0, 0.0, 10000000000.0, 123.45)), 1, false); TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rsqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_float() { TestUtils.AreEqual(-0.008100445f, rcp(-123.45f), 1, false); @@ -1796,7 +1796,7 @@ public static void rcp_float() TestUtils.AreEqual(0f, rcp(float.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_float2() { TestUtils.AreEqual(float2(-0.008100445f, float.PositiveInfinity), rcp(float2(-123.45f, 0f)), 1, false); @@ -1804,21 +1804,21 @@ public static void rcp_float2() TestUtils.AreEqual(float2(0f, 0f), rcp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_float3() { TestUtils.AreEqual(float3(-0.008100445f, float.PositiveInfinity, 0.008100445f), rcp(float3(-123.45f, 0f, 123.45f)), 1, false); TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0f), rcp(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_float4() { TestUtils.AreEqual(float4(-0.008100445f, float.PositiveInfinity, 0.008100445f, TestUtils.SignedFloatQNaN()), rcp(float4(-123.45f, 0f, 123.45f, TestUtils.SignedFloatQNaN())), 1, false); TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), rcp(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_double() { TestUtils.AreEqual(-0.0081004455245038479, rcp(-123.45), 1, false); @@ -1828,7 +1828,7 @@ public static void rcp_double() TestUtils.AreEqual(0.0, rcp(double.PositiveInfinity), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_double2() { TestUtils.AreEqual(double2(-0.0081004455245038479, double.PositiveInfinity), rcp(double2(-123.45, 0.0)), 1, false); @@ -1836,21 +1836,21 @@ public static void rcp_double2() TestUtils.AreEqual(double2(0.0, 0.0), rcp(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_double3() { TestUtils.AreEqual(double3(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479), rcp(double3(-123.45, 0.0, 123.45)), 1, false); TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rcp(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rcp_double4() { TestUtils.AreEqual(double4(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479, TestUtils.SignedDoubleQNaN()), rcp(double4(-123.45, 0.0, 123.45, TestUtils.SignedDoubleQNaN())), 1, false); TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), rcp(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_float() { TestUtils.AreEqual(float.NegativeInfinity, floor(float.NegativeInfinity)); @@ -1865,7 +1865,7 @@ public static void floor_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), floor(TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), floor(float2(float.NegativeInfinity, -100.51f))); @@ -1875,7 +1875,7 @@ public static void floor_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), floor(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -101f), floor(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -1884,7 +1884,7 @@ public static void floor_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -101f, -101f), floor(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -1892,7 +1892,7 @@ public static void floor_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_double() { TestUtils.AreEqual(double.NegativeInfinity, floor(double.NegativeInfinity)); @@ -1907,7 +1907,7 @@ public static void floor_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), floor(TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), floor(double2(double.NegativeInfinity, -100.51))); @@ -1917,7 +1917,7 @@ public static void floor_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), floor(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -101.0), floor(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -1926,7 +1926,7 @@ public static void floor_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floor_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -101.0, -101.0), floor(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -1934,7 +1934,7 @@ public static void floor_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_float() { TestUtils.AreEqual(float.NegativeInfinity, ceil(float.NegativeInfinity)); @@ -1949,7 +1949,7 @@ public static void ceil_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), ceil(TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), ceil(float2(float.NegativeInfinity, -100.51f))); @@ -1959,7 +1959,7 @@ public static void ceil_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), ceil(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), ceil(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -1968,7 +1968,7 @@ public static void ceil_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), ceil(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -1976,7 +1976,7 @@ public static void ceil_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_double() { TestUtils.AreEqual(double.NegativeInfinity, ceil(double.NegativeInfinity)); @@ -1991,7 +1991,7 @@ public static void ceil_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), ceil(TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), ceil(double2(double.NegativeInfinity, -100.51))); @@ -2001,7 +2001,7 @@ public static void ceil_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), ceil(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), ceil(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -2010,7 +2010,7 @@ public static void ceil_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceil_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), ceil(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -2018,7 +2018,7 @@ public static void ceil_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_float() { TestUtils.AreEqual(float.NegativeInfinity, round(float.NegativeInfinity)); @@ -2034,7 +2034,7 @@ public static void round_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), round(TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), round(float2(float.NegativeInfinity, -100.51f))); @@ -2045,7 +2045,7 @@ public static void round_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -100f), round(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -2054,7 +2054,7 @@ public static void round_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -100f, -100f), round(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -2062,7 +2062,7 @@ public static void round_float4() TestUtils.AreEqual(float4(102f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_double() { TestUtils.AreEqual(double.NegativeInfinity, round(double.NegativeInfinity)); @@ -2078,7 +2078,7 @@ public static void round_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), round(TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), round(double2(double.NegativeInfinity, -100.51))); @@ -2089,7 +2089,7 @@ public static void round_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -100.0), round(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -2098,7 +2098,7 @@ public static void round_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void round_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -100.0, -100.0), round(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -2106,7 +2106,7 @@ public static void round_double4() TestUtils.AreEqual(double4(102.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_float() { TestUtils.AreEqual(float.NegativeInfinity, trunc(float.NegativeInfinity)); @@ -2122,7 +2122,7 @@ public static void trunc_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), trunc(TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), trunc(float2(float.NegativeInfinity, -100.51f))); @@ -2133,7 +2133,7 @@ public static void trunc_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), trunc(float3(float.NegativeInfinity, -100.51f, -100.5f))); @@ -2142,7 +2142,7 @@ public static void trunc_float3() TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), trunc(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f))); @@ -2150,7 +2150,7 @@ public static void trunc_float4() TestUtils.AreEqual(float4(101f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_double() { TestUtils.AreEqual(double.NegativeInfinity, trunc(double.NegativeInfinity)); @@ -2166,7 +2166,7 @@ public static void trunc_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), trunc(TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), trunc(double2(double.NegativeInfinity, -100.51))); @@ -2177,7 +2177,7 @@ public static void trunc_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), trunc(double3(double.NegativeInfinity, -100.51, -100.5))); @@ -2186,7 +2186,7 @@ public static void trunc_double3() TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void trunc_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), trunc(double4(double.NegativeInfinity, -100.51, -100.5, -100.49))); @@ -2194,7 +2194,7 @@ public static void trunc_double4() TestUtils.AreEqual(double4(101.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(float.NegativeInfinity), 64, false); @@ -2206,7 +2206,7 @@ public static void frac_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(TestUtils.SignedFloatQNaN()), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), frac(float2(float.NegativeInfinity, -1E+20f)), 64, false); @@ -2215,7 +2215,7 @@ public static void frac_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0.7f), frac(float3(float.NegativeInfinity, -1E+20f, -100.3f)), 64, false); @@ -2223,14 +2223,14 @@ public static void frac_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 0.7f, 0f), frac(float4(float.NegativeInfinity, -1E+20f, -100.3f, 0f)), 64, false); TestUtils.AreEqual(float4(0.8f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float4(100.8f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(double.NegativeInfinity), 64, false); @@ -2242,7 +2242,7 @@ public static void frac_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(TestUtils.SignedDoubleQNaN()), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), frac(double2(double.NegativeInfinity, -1E+20)), 64, false); @@ -2251,7 +2251,7 @@ public static void frac_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.7), frac(double3(double.NegativeInfinity, -1E+20, -100.3)), 64, false); @@ -2259,14 +2259,14 @@ public static void frac_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void frac_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 0.7, 0.0), frac(double4(double.NegativeInfinity, -1E+20, -100.3, 0.0)), 64, false); TestUtils.AreEqual(double4(0.8, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double4(100.8, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_float() { TestUtils.AreEqual(-967.77f, lerp(-123.45f, 439.43f, -1.5f), 1, false); @@ -2275,27 +2275,27 @@ public static void lerp_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), lerp(-123.45f, 439.43f, TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_float2() { TestUtils.AreEqual(float2(-967.77f, 157.99f), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-1.5f, 0.5f)), 1, false); TestUtils.AreEqual(float2(2972.39f, TestUtils.SignedFloatQNaN()), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(5.5f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_float3() { TestUtils.AreEqual(float3(-967.77f, 157.99f, 2972.39f), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-1.5f, 0.5f, 5.5f)), 1, false); TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_float4() { TestUtils.AreEqual(float4(-967.77f, 157.99f, 2972.39f, TestUtils.SignedFloatQNaN()), lerp(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f), float4(-1.5f, 0.5f, 5.5f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_double() { TestUtils.AreEqual(-967.77, lerp(-123.45, 439.43, -1.5), 1, false); @@ -2304,27 +2304,27 @@ public static void lerp_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), lerp(-123.45, 439.43, TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_double2() { TestUtils.AreEqual(double2(-967.77, 157.99), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-1.5, 0.5)), 1, false); TestUtils.AreEqual(double2(2972.39, TestUtils.SignedDoubleQNaN()), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(5.5, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_double3() { TestUtils.AreEqual(double3(-967.77, 157.99, 2972.39), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-1.5, 0.5, 5.5)), 1, false); TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void lerp_double4() { TestUtils.AreEqual(double4(-967.77, 157.99, 2972.39, TestUtils.SignedDoubleQNaN()), lerp(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43), double4(-1.5, 0.5, 5.5, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_float() { TestUtils.AreEqual(-0.232465178f, unlerp(-123.45f, 439.43f, -254.3f), 4, false); @@ -2337,7 +2337,7 @@ public static void unlerp_float() TestUtils.AreEqual(-0.3422932f, unlerp(439.43f, -123.45f, 632.1f), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_float2() { TestUtils.AreEqual(float2(-0.232465178f, 0.219318509f), unlerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-254.3f, 0f)), 4, false); @@ -2346,7 +2346,7 @@ public static void unlerp_float2() TestUtils.AreEqual(float2(0.7806815f, -0.3422932f), unlerp(float2(439.43f, 439.43f), float2(-123.45f, -123.45f), float2(0f, 632.1f)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_float3() { TestUtils.AreEqual(float3(-0.232465178f, 0.219318509f, 1.34229326f), unlerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-254.3f, 0f, 632.1f)), 4, false); @@ -2354,14 +2354,14 @@ public static void unlerp_float3() TestUtils.AreEqual(float3(0.7806815f, -0.3422932f, -0.3422932f), unlerp(float3(439.43f, 439.43f, 439.43f), float3(-123.45f, -123.45f, -123.45f), float3(0f, 632.1f, 632.1f)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_float4() { TestUtils.AreEqual(float4(-0.232465178f, 0.219318509f, 1.34229326f, float.NegativeInfinity), unlerp(float4(-123.45f, -123.45f, -123.45f, 123.4f), float4(439.43f, 439.43f, 439.43f, 123.4f), float4(-254.3f, 0f, 632.1f, -430f)), 4, false); TestUtils.AreEqual(float4(float.PositiveInfinity, 1.23246515f, 0.7806815f, -0.3422932f), unlerp(float4(123.4f, 439.43f, 439.43f, 439.43f), float4(123.4f, -123.45f, -123.45f, -123.45f), float4(430f, -254.3f, 0f, 632.1f)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_double() { TestUtils.AreEqual(-0.23246517907902217, unlerp(-123.45, 439.43, -254.3), 4, false); @@ -2374,7 +2374,7 @@ public static void unlerp_double() TestUtils.AreEqual(-0.34229320636725413, unlerp(439.43, -123.45, 632.1), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_double2() { TestUtils.AreEqual(double2(-0.23246517907902217, 0.21931850483229107), unlerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-254.3, 0.0)), 4, false); @@ -2383,7 +2383,7 @@ public static void unlerp_double2() TestUtils.AreEqual(double2(0.78068149516770891, -0.34229320636725413), unlerp(double2(439.43, 439.43), double2(-123.45, -123.45), double2(0.0, 632.1)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_double3() { TestUtils.AreEqual(double3(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541), unlerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-254.3, 0.0, 632.1)), 4, false); @@ -2391,14 +2391,14 @@ public static void unlerp_double3() TestUtils.AreEqual(double3(0.78068149516770891, -0.34229320636725413, -0.34229320636725413), unlerp(double3(439.43, 439.43, 439.43), double3(-123.45, -123.45, -123.45), double3(0.0, 632.1, 632.1)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void unlerp_double4() { TestUtils.AreEqual(double4(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541, double.NegativeInfinity), unlerp(double4(-123.45, -123.45, -123.45, 123.4), double4(439.43, 439.43, 439.43, 123.4), double4(-254.3, 0.0, 632.1, -430.0)), 4, false); TestUtils.AreEqual(double4(double.PositiveInfinity, 1.2324651790790222, 0.78068149516770891, -0.34229320636725413), unlerp(double4(123.4, 439.43, 439.43, 439.43), double4(123.4, -123.45, -123.45, -123.45), double4(430.0, -254.3, 0.0, 632.1)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_float() { TestUtils.AreEqual(529.0331f, remap(-123.45f, 439.43f, 541.3f, 631.5f, -200f), 4, false); @@ -2414,7 +2414,7 @@ public static void remap_float() TestUtils.AreEqual(float.PositiveInfinity, remap(-123.45f, -123.45f, 541.3f, 631.5f, -100f), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_float2() { TestUtils.AreEqual(float2(529.0331f, 545.0578f), remap(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-200f, -100f)), 4, false); @@ -2425,7 +2425,7 @@ public static void remap_float2() TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), remap(float2(-123.45f, -123.45f), float2(-123.45f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-100f, -100f)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_float3() { TestUtils.AreEqual(float3(529.0331f, 545.0578f, 641.2062f), remap(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, 500f)), 4, false); @@ -2434,7 +2434,7 @@ public static void remap_float3() TestUtils.AreEqual(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float3(-123.45f, -123.45f, -123.45f), float3(-123.45f, -123.45f, -123.45f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, -100f)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_float4() { TestUtils.AreEqual(float4(529.0331f, 545.0578f, 641.2062f, 643.7669f), remap(float4(-123.45f, -123.45f, -123.45f, 439.43f), float4(439.43f, 439.43f, 439.43f, -123.45f), float4(541.3f, 541.3f, 541.3f, 541.3f), float4(631.5f, 631.5f, 631.5f, 631.5f), float4(-200f, -100f, 500f, -200f)), 4, false); @@ -2442,7 +2442,7 @@ public static void remap_float4() TestUtils.AreEqual(float4(531.5938f, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, -123.45f, -123.45f, -123.45f), float4(631.5f, 541.3f, 541.3f, 541.3f), float4(541.3f, 631.5f, 631.5f, 631.5f), float4(500f, -200f, -100f, -100f)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_double() { TestUtils.AreEqual(529.03306921546334, remap(-123.45, 439.43, 541.3, 631.5, -200.0), 4, false); @@ -2458,7 +2458,7 @@ public static void remap_double() TestUtils.AreEqual(double.PositiveInfinity, remap(-123.45, -123.45, 541.3, 631.5, -100.0), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_double2() { TestUtils.AreEqual(double2(529.03306921546334, 545.057799175668), remap(double2(-123.45, -123.45), double2(439.43, 439.43), double2(541.3, 541.3), double2(631.5, 631.5), double2(-200.0, -100.0)), 4, false); @@ -2469,7 +2469,7 @@ public static void remap_double2() TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), remap(double2(-123.45, -123.45), double2(-123.45, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(-100.0, -100.0)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_double3() { TestUtils.AreEqual(double3(529.03306921546334, 545.057799175668, 641.206178936896), remap(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, 500.0)), 4, false); @@ -2478,7 +2478,7 @@ public static void remap_double3() TestUtils.AreEqual(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double3(-123.45, -123.45, -123.45), double3(-123.45, -123.45, -123.45), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, -100.0)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void remap_double4() { TestUtils.AreEqual(double4(529.03306921546334, 545.057799175668, 641.206178936896, 643.76693078453673), remap(double4(-123.45, -123.45, -123.45, 439.43), double4(439.43, 439.43, 439.43, -123.45), double4(541.3, 541.3, 541.3, 541.3), double4(631.5, 631.5, 631.5, 631.5), double4(-200.0, -100.0, 500.0, -200.0)), 4, false); @@ -2486,7 +2486,7 @@ public static void remap_double4() TestUtils.AreEqual(double4(531.59382106310409, double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, -123.45, -123.45, -123.45), double4(631.5, 541.3, 541.3, 541.3), double4(541.3, 631.5, 631.5, 631.5), double4(500.0, -200.0, -100.0, -100.0)), 4, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_int() { TestUtils.AreEqual(-123, clamp(-2147483648, -123, 439)); @@ -2499,7 +2499,7 @@ public static void clamp_int() TestUtils.AreEqual(439, clamp(2147483647, -123, 439)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_int2() { TestUtils.AreEqual(int2(-123, -123), clamp(int2(-2147483648, -254), int2(-123, -123), int2(439, 439))); @@ -2508,7 +2508,7 @@ public static void clamp_int2() TestUtils.AreEqual(int2(439, 439), clamp(int2(632, 2147483647), int2(439, -123), int2(-123, 439))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_int3() { TestUtils.AreEqual(int3(-123, -123, 246), clamp(int3(-2147483648, -254, 246), int3(-123, -123, -123), int3(439, 439, 439))); @@ -2516,14 +2516,14 @@ public static void clamp_int3() TestUtils.AreEqual(int3(439, 439, 439), clamp(int3(632, 2147483647, 2147483647), int3(439, -123, -123), int3(-123, 439, 439))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_int4() { TestUtils.AreEqual(int4(-123, -123, 246, 439), clamp(int4(-2147483648, -254, 246, 632), int4(-123, -123, -123, -123), int4(439, 439, 439, 439))); TestUtils.AreEqual(int4(439, 439, 439, 439), clamp(int4(-254, 246, 632, 2147483647), int4(439, 439, 439, -123), int4(-123, -123, -123, 439))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_uint() { TestUtils.AreEqual(123u, clamp(0u, 123u, 439u)); @@ -2536,7 +2536,7 @@ public static void clamp_uint() TestUtils.AreEqual(439u, clamp(4294967295u, 123u, 439u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_uint2() { TestUtils.AreEqual(uint2(123u, 123u), clamp(uint2(0u, 54u), uint2(123u, 123u), uint2(439u, 439u))); @@ -2545,7 +2545,7 @@ public static void clamp_uint2() TestUtils.AreEqual(uint2(439u, 439u), clamp(uint2(632u, 4294967295u), uint2(439u, 123u), uint2(123u, 439u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_uint3() { TestUtils.AreEqual(uint3(123u, 123u, 246u), clamp(uint3(0u, 54u, 246u), uint3(123u, 123u, 123u), uint3(439u, 439u, 439u))); @@ -2553,14 +2553,14 @@ public static void clamp_uint3() TestUtils.AreEqual(uint3(439u, 439u, 439u), clamp(uint3(632u, 4294967295u, 4294967295u), uint3(439u, 123u, 123u), uint3(123u, 439u, 439u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_uint4() { TestUtils.AreEqual(uint4(123u, 123u, 246u, 439u), clamp(uint4(0u, 54u, 246u, 632u), uint4(123u, 123u, 123u, 123u), uint4(439u, 439u, 439u, 439u))); TestUtils.AreEqual(uint4(439u, 439u, 439u, 439u), clamp(uint4(54u, 246u, 632u, 4294967295u), uint4(439u, 439u, 439u, 123u), uint4(123u, 123u, 123u, 439u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_long() { TestUtils.AreEqual(-123L, clamp(-9223372036854775808L, -123L, 439L)); @@ -2573,7 +2573,7 @@ public static void clamp_long() TestUtils.AreEqual(439L, clamp(9223372036854775807L, -123L, 439L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_ulong() { TestUtils.AreEqual(123UL, clamp(0UL, 123UL, 439UL)); @@ -2586,7 +2586,7 @@ public static void clamp_ulong() TestUtils.AreEqual(439UL, clamp(18446744073709551615UL, 123UL, 439UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_float() { TestUtils.AreEqual(-123.45f, clamp(float.NegativeInfinity, -123.45f, 439.43f)); @@ -2600,7 +2600,7 @@ public static void clamp_float() TestUtils.AreEqual(439.43f, clamp(TestUtils.SignedFloatQNaN(), -123.45f, 439.43f)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_float2() { TestUtils.AreEqual(float2(-123.45f, -123.45f), clamp(float2(float.NegativeInfinity, -254.3f), float2(-123.45f, -123.45f), float2(439.43f, 439.43f))); @@ -2610,7 +2610,7 @@ public static void clamp_float2() TestUtils.AreEqual(float2(439.43f, 439.43f), clamp(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(-123.45f, -123.45f), float2(439.43f, 439.43f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_float3() { TestUtils.AreEqual(float3(-123.45f, -123.45f, 246.3f), clamp(float3(float.NegativeInfinity, -254.3f, 246.3f), float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f))); @@ -2618,7 +2618,7 @@ public static void clamp_float3() TestUtils.AreEqual(float3(439.43f, 439.43f, 439.43f), clamp(float3(632.1f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(439.43f, -123.45f, -123.45f), float3(-123.45f, 439.43f, 439.43f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_float4() { TestUtils.AreEqual(float4(-123.45f, -123.45f, 246.3f, 439.43f), clamp(float4(float.NegativeInfinity, -254.3f, 246.3f, 632.1f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f))); @@ -2626,7 +2626,7 @@ public static void clamp_float4() TestUtils.AreEqual(float4(439.43f, 439.43f, 439.43f, 439.43f), clamp(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_double() { TestUtils.AreEqual(-123.45, clamp(double.NegativeInfinity, -123.45, 439.43)); @@ -2640,7 +2640,7 @@ public static void clamp_double() TestUtils.AreEqual(439.43, clamp(TestUtils.SignedDoubleQNaN(), -123.45, 439.43)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_double2() { TestUtils.AreEqual(double2(-123.45, -123.45), clamp(double2(double.NegativeInfinity, -254.3), double2(-123.45, -123.45), double2(439.43, 439.43))); @@ -2650,7 +2650,7 @@ public static void clamp_double2() TestUtils.AreEqual(double2(439.43, 439.43), clamp(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(-123.45, -123.45), double2(439.43, 439.43))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_double3() { TestUtils.AreEqual(double3(-123.45, -123.45, 246.3), clamp(double3(double.NegativeInfinity, -254.3, 246.3), double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43))); @@ -2658,7 +2658,7 @@ public static void clamp_double3() TestUtils.AreEqual(double3(439.43, 439.43, 439.43), clamp(double3(632.1, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(439.43, -123.45, -123.45), double3(-123.45, 439.43, 439.43))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void clamp_double4() { TestUtils.AreEqual(double4(-123.45, -123.45, 246.3, 439.43), clamp(double4(double.NegativeInfinity, -254.3, 246.3, 632.1), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43))); @@ -2666,7 +2666,7 @@ public static void clamp_double4() TestUtils.AreEqual(double4(439.43, 439.43, 439.43, 439.43), clamp(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_float() { TestUtils.AreEqual(0f, saturate(float.NegativeInfinity)); @@ -2679,7 +2679,7 @@ public static void saturate_float() TestUtils.AreEqual(1f, saturate(TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_float2() { TestUtils.AreEqual(float2(0f, 0f), saturate(float2(float.NegativeInfinity, -123.45f))); @@ -2688,7 +2688,7 @@ public static void saturate_float2() TestUtils.AreEqual(float2(1f, 1f), saturate(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_float3() { TestUtils.AreEqual(float3(0f, 0f, 0f), saturate(float3(float.NegativeInfinity, -123.45f, 0f))); @@ -2696,14 +2696,14 @@ public static void saturate_float3() TestUtils.AreEqual(float3(1f, 1f, 1f), saturate(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_float4() { TestUtils.AreEqual(float4(0f, 0f, 0f, 0.5f), saturate(float4(float.NegativeInfinity, -123.45f, 0f, 0.5f))); TestUtils.AreEqual(float4(1f, 1f, 1f, 1f), saturate(float4(1f, 123.45f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_double() { TestUtils.AreEqual(0.0, saturate(double.NegativeInfinity)); @@ -2716,7 +2716,7 @@ public static void saturate_double() TestUtils.AreEqual(1.0, saturate(TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_double2() { TestUtils.AreEqual(double2(0.0, 0.0), saturate(double2(double.NegativeInfinity, -123.45))); @@ -2725,7 +2725,7 @@ public static void saturate_double2() TestUtils.AreEqual(double2(1.0, 1.0), saturate(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_double3() { TestUtils.AreEqual(double3(0.0, 0.0, 0.0), saturate(double3(double.NegativeInfinity, -123.45, 0.0))); @@ -2733,14 +2733,14 @@ public static void saturate_double3() TestUtils.AreEqual(double3(1.0, 1.0, 1.0), saturate(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void saturate_double4() { TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.5), saturate(double4(double.NegativeInfinity, -123.45, 0.0, 0.5))); TestUtils.AreEqual(double4(1.0, 1.0, 1.0, 1.0), saturate(double4(1.0, 123.45, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_float() { TestUtils.AreEqual(0f, step(-123.45f, float.NegativeInfinity)); @@ -2770,7 +2770,7 @@ public static void step_float() TestUtils.AreEqual(0f, step(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_float2() { TestUtils.AreEqual(float2(0f, 0f), step(float2(-123.45f, -123.45f), float2(float.NegativeInfinity, -200f))); @@ -2788,7 +2788,7 @@ public static void step_float2() TestUtils.AreEqual(float2(0f, 0f), step(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_float3() { TestUtils.AreEqual(float3(0f, 0f, 1f), step(float3(-123.45f, -123.45f, -123.45f), float3(float.NegativeInfinity, -200f, 200f))); @@ -2802,7 +2802,7 @@ public static void step_float3() TestUtils.AreEqual(float3(0f, 0f, 0f), step(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_float4() { TestUtils.AreEqual(float4(0f, 0f, 1f, 1f), step(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(float.NegativeInfinity, -200f, 200f, float.PositiveInfinity))); @@ -2814,7 +2814,7 @@ public static void step_float4() TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), step(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_double() { TestUtils.AreEqual(0.0, step(-123.45, double.NegativeInfinity)); @@ -2844,7 +2844,7 @@ public static void step_double() TestUtils.AreEqual(0.0, step(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_double2() { TestUtils.AreEqual(double2(0.0, 0.0), step(double2(-123.45, -123.45), double2(double.NegativeInfinity, -200.0))); @@ -2862,7 +2862,7 @@ public static void step_double2() TestUtils.AreEqual(double2(0.0, 0.0), step(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_double3() { TestUtils.AreEqual(double3(0.0, 0.0, 1.0), step(double3(-123.45, -123.45, -123.45), double3(double.NegativeInfinity, -200.0, 200.0))); @@ -2876,7 +2876,7 @@ public static void step_double3() TestUtils.AreEqual(double3(0.0, 0.0, 0.0), step(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void step_double4() { TestUtils.AreEqual(double4(0.0, 0.0, 1.0, 1.0), step(double4(-123.45, -123.45, -123.45, -123.45), double4(double.NegativeInfinity, -200.0, 200.0, double.PositiveInfinity))); @@ -2888,7 +2888,7 @@ public static void step_double4() TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), step(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_int() { TestUtils.AreEqual(-2147483648, min(-2147483648, -2147483648)); @@ -2906,7 +2906,7 @@ public static void min_int() TestUtils.AreEqual(2147483647, min(2147483647, 2147483647)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_int2() { TestUtils.AreEqual(int2(-2147483648, -2147483648), min(int2(-2147483648, -2147483648), int2(-2147483648, -1))); @@ -2918,7 +2918,7 @@ public static void min_int2() TestUtils.AreEqual(int2(2147483647, 2147483647), min(int2(2147483647, 2147483647), int2(2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_int3() { TestUtils.AreEqual(int3(-2147483648, -2147483648, -2147483648), min(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648))); @@ -2928,7 +2928,7 @@ public static void min_int3() TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), min(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_int4() { TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -3456), min(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456))); @@ -2937,7 +2937,7 @@ public static void min_int4() TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), min(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_uint() { TestUtils.AreEqual(1234u, min(1234u, 3456u)); @@ -2949,7 +2949,7 @@ public static void min_uint() TestUtils.AreEqual(4294967295u, min(4294967295u, 4294967295u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_uint2() { TestUtils.AreEqual(uint2(1234u, 1234u), min(uint2(1234u, 3456u), uint2(3456u, 1234u))); @@ -2958,7 +2958,7 @@ public static void min_uint2() TestUtils.AreEqual(uint2(4294967295u, 4294967295u), min(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_uint3() { TestUtils.AreEqual(uint3(1234u, 1234u, 7u), min(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u))); @@ -2966,14 +2966,14 @@ public static void min_uint3() TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), min(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_uint4() { TestUtils.AreEqual(uint4(1234u, 1234u, 7u, 7u), min(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u))); TestUtils.AreEqual(uint4(1u, 1u, 4294967295u, 4294967295u), min(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_long() { TestUtils.AreEqual(-9223372036854775808L, min(-9223372036854775808L, -9223372036854775808L)); @@ -2991,7 +2991,7 @@ public static void min_long() TestUtils.AreEqual(9223372036854775807L, min(9223372036854775807L, 9223372036854775807L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_ulong() { TestUtils.AreEqual(1234UL, min(1234UL, 3456UL)); @@ -3003,7 +3003,7 @@ public static void min_ulong() TestUtils.AreEqual(18446744073709551615UL, min(18446744073709551615UL, 18446744073709551615UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_float() { TestUtils.AreEqual(float.NegativeInfinity, min(float.NegativeInfinity, float.NegativeInfinity)); @@ -3024,7 +3024,7 @@ public static void min_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), min(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, float.NegativeInfinity), min(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f))); @@ -3037,7 +3037,7 @@ public static void min_float2() TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), min(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), min(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity))); @@ -3048,7 +3048,7 @@ public static void min_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), min(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -3456.7f), min(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f))); @@ -3057,7 +3057,7 @@ public static void min_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), min(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_double() { TestUtils.AreEqual(double.NegativeInfinity, min(double.NegativeInfinity, double.NegativeInfinity)); @@ -3078,7 +3078,7 @@ public static void min_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), min(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, double.NegativeInfinity), min(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0))); @@ -3091,7 +3091,7 @@ public static void min_double2() TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), min(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity), min(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity))); @@ -3102,7 +3102,7 @@ public static void min_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), min(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void min_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -3456.7), min(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7))); @@ -3111,7 +3111,7 @@ public static void min_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), min(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_int() { TestUtils.AreEqual(-2147483648, max(-2147483648, -2147483648)); @@ -3129,7 +3129,7 @@ public static void max_int() TestUtils.AreEqual(2147483647, max(2147483647, 2147483647)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_int2() { TestUtils.AreEqual(int2(-2147483648, -1), max(int2(-2147483648, -2147483648), int2(-2147483648, -1))); @@ -3141,7 +3141,7 @@ public static void max_int2() TestUtils.AreEqual(int2(2147483647, 2147483647), max(int2(2147483647, 2147483647), int2(2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_int3() { TestUtils.AreEqual(int3(-2147483648, -1, -1), max(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648))); @@ -3151,7 +3151,7 @@ public static void max_int3() TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), max(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_int4() { TestUtils.AreEqual(int4(-2147483648, -1, -1, -1234), max(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456))); @@ -3160,7 +3160,7 @@ public static void max_int4() TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), max(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_uint() { TestUtils.AreEqual(3456u, max(1234u, 3456u)); @@ -3172,7 +3172,7 @@ public static void max_uint() TestUtils.AreEqual(4294967295u, max(4294967295u, 4294967295u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_uint2() { TestUtils.AreEqual(uint2(3456u, 3456u), max(uint2(1234u, 3456u), uint2(3456u, 1234u))); @@ -3181,7 +3181,7 @@ public static void max_uint2() TestUtils.AreEqual(uint2(4294967295u, 4294967295u), max(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_uint3() { TestUtils.AreEqual(uint3(3456u, 3456u, 4294967040u), max(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u))); @@ -3189,14 +3189,14 @@ public static void max_uint3() TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), max(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_uint4() { TestUtils.AreEqual(uint4(3456u, 3456u, 4294967040u, 4294967040u), max(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u))); TestUtils.AreEqual(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u), max(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_long() { TestUtils.AreEqual(-9223372036854775808L, max(-9223372036854775808L, -9223372036854775808L)); @@ -3214,7 +3214,7 @@ public static void max_long() TestUtils.AreEqual(9223372036854775807L, max(9223372036854775807L, 9223372036854775807L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_ulong() { TestUtils.AreEqual(3456UL, max(1234UL, 3456UL)); @@ -3226,7 +3226,7 @@ public static void max_ulong() TestUtils.AreEqual(18446744073709551615UL, max(18446744073709551615UL, 18446744073709551615UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_float() { TestUtils.AreEqual(float.NegativeInfinity, max(float.NegativeInfinity, float.NegativeInfinity)); @@ -3247,7 +3247,7 @@ public static void max_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), max(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_float2() { TestUtils.AreEqual(float2(float.NegativeInfinity, -1f), max(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f))); @@ -3260,7 +3260,7 @@ public static void max_float2() TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), max(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_float3() { TestUtils.AreEqual(float3(float.NegativeInfinity, -1f, -1f), max(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity))); @@ -3271,7 +3271,7 @@ public static void max_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), max(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_float4() { TestUtils.AreEqual(float4(float.NegativeInfinity, -1f, -1f, -1234.56f), max(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f))); @@ -3280,7 +3280,7 @@ public static void max_float4() TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), max(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_double() { TestUtils.AreEqual(double.NegativeInfinity, max(double.NegativeInfinity, double.NegativeInfinity)); @@ -3301,7 +3301,7 @@ public static void max_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), max(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_double2() { TestUtils.AreEqual(double2(double.NegativeInfinity, -1.0), max(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0))); @@ -3314,7 +3314,7 @@ public static void max_double2() TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), max(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_double3() { TestUtils.AreEqual(double3(double.NegativeInfinity, -1.0, -1.0), max(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity))); @@ -3325,7 +3325,7 @@ public static void max_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), max(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void max_double4() { TestUtils.AreEqual(double4(double.NegativeInfinity, -1.0, -1.0, -1234.56), max(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7))); @@ -3334,7 +3334,7 @@ public static void max_double4() TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), max(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_float() { TestUtils.AreEqual(0f, smoothstep(-123.45f, 345.6f, float.NegativeInfinity), 8, false); @@ -3351,7 +3351,7 @@ public static void smoothstep_float() TestUtils.AreEqual(1f, smoothstep(345.6f, -123.45f, TestUtils.SignedFloatQNaN()), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_float2() { TestUtils.AreEqual(float2(0f, 0f), smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(float.NegativeInfinity, -200f)), 8, false); @@ -3362,7 +3362,7 @@ public static void smoothstep_float2() TestUtils.AreEqual(float2(0f, 1f), smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_float3() { TestUtils.AreEqual(float3(0f, 0f, 0.00724848127f), smoothstep(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(float.NegativeInfinity, -200f, -100f)), 8, false); @@ -3371,7 +3371,7 @@ public static void smoothstep_float3() TestUtils.AreEqual(float3(0f, 0f, 1f), smoothstep(float3(345.6f, 345.6f, 345.6f), float3(-123.45f, -123.45f, -123.45f), float3(400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_float4() { TestUtils.AreEqual(float4(0f, 0f, 0.00724848127f, 1f), smoothstep(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(345.6f, 345.6f, 345.6f, 345.6f), float4(float.NegativeInfinity, -200f, -100f, 400f)), 8, false); @@ -3379,7 +3379,7 @@ public static void smoothstep_float4() TestUtils.AreEqual(float4(0.992751539f, 0f, 0f, 1f), smoothstep(float4(345.6f, 345.6f, 345.6f, 345.6f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(-100f, 400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_double() { TestUtils.AreEqual(0.0, smoothstep(-123.45, 345.6, double.NegativeInfinity), 8, false); @@ -3396,7 +3396,7 @@ public static void smoothstep_double() TestUtils.AreEqual(1.0, smoothstep(345.6, -123.45, TestUtils.SignedDoubleQNaN()), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_double2() { TestUtils.AreEqual(double2(0.0, 0.0), smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(double.NegativeInfinity, -200.0)), 8, false); @@ -3407,7 +3407,7 @@ public static void smoothstep_double2() TestUtils.AreEqual(double2(0.0, 1.0), smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_double3() { TestUtils.AreEqual(double3(0.0, 0.0, 0.0072484810488798995), smoothstep(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(double.NegativeInfinity, -200.0, -100.0)), 8, false); @@ -3416,7 +3416,7 @@ public static void smoothstep_double3() TestUtils.AreEqual(double3(0.0, 0.0, 1.0), smoothstep(double3(345.6, 345.6, 345.6), double3(-123.45, -123.45, -123.45), double3(400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void smoothstep_double4() { TestUtils.AreEqual(double4(0.0, 0.0, 0.0072484810488798995, 1.0), smoothstep(double4(-123.45, -123.45, -123.45, -123.45), double4(345.6, 345.6, 345.6, 345.6), double4(double.NegativeInfinity, -200.0, -100.0, 400.0)), 8, false); @@ -3424,7 +3424,7 @@ public static void smoothstep_double4() TestUtils.AreEqual(double4(0.99275151895112013, 0.0, 0.0, 1.0), smoothstep(double4(345.6, 345.6, 345.6, 345.6), double4(-123.45, -123.45, -123.45, -123.45), double4(-100.0, 400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_int() { TestUtils.AreEqual(7097663, mad(1234, 5678, 91011)); @@ -3445,7 +3445,7 @@ public static void mad_int() TestUtils.AreEqual(1313707278, mad(-98765, -56789, -91011)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_int2() { TestUtils.AreEqual(int2(7097663, 6915641), mad(int2(1234, 1234), int2(5678, 5678), int2(91011, -91011))); @@ -3458,7 +3458,7 @@ public static void mad_int2() TestUtils.AreEqual(int2(1313889300, 1313707278), mad(int2(-98765, -98765), int2(-56789, -56789), int2(91011, -91011))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_int3() { TestUtils.AreEqual(int3(7097663, 6915641, -6915641), mad(int3(1234, 1234, 1234), int3(5678, 5678, -5678), int3(91011, -91011, 91011))); @@ -3469,7 +3469,7 @@ public static void mad_int3() TestUtils.AreEqual(int3(1313707278, 1313707278, 1313707278), mad(int3(-98765, -98765, -98765), int3(-56789, -56789, -56789), int3(-91011, -91011, -91011))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_int4() { TestUtils.AreEqual(int4(7097663, 6915641, -6915641, -7097663), mad(int4(1234, 1234, 1234, 1234), int4(5678, 5678, -5678, -5678), int4(91011, -91011, 91011, -91011))); @@ -3478,32 +3478,32 @@ public static void mad_int4() TestUtils.AreEqual(int4(-1313707278, -1313889300, 1313889300, 1313707278), mad(int4(-98765, -98765, -98765, -98765), int4(56789, 56789, -56789, -56789), int4(91011, -91011, 91011, -91011))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_uint() { TestUtils.AreEqual(7097663u, mad(1234u, 5678u, 91011u)); TestUtils.AreEqual(1313889300u, mad(98765u, 56789u, 91011u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_uint2() { TestUtils.AreEqual(uint2(7097663u, 1313889300u), mad(uint2(1234u, 98765u), uint2(5678u, 56789u), uint2(91011u, 91011u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_uint3() { TestUtils.AreEqual(uint3(7097663u, 1313889300u, 1313889300u), mad(uint3(1234u, 98765u, 98765u), uint3(5678u, 56789u, 56789u), uint3(91011u, 91011u, 91011u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_uint4() { TestUtils.AreEqual(uint4(7097663u, 1313889300u, 1313889300u, 1313889300u), mad(uint4(1234u, 98765u, 98765u, 98765u), uint4(5678u, 56789u, 56789u, 56789u), uint4(91011u, 91011u, 91011u, 91011u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_long() { TestUtils.AreEqual(7097663L, mad(1234L, 5678L, 91011L)); @@ -3524,14 +3524,14 @@ public static void mad_long() TestUtils.AreEqual(747681192693554158L, mad(-9876543210L, -5678901234L, -9101112134L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_ulong() { TestUtils.AreEqual(7097663L, mad(1234UL, 5678UL, 91011UL)); TestUtils.AreEqual(747681210895778426L, mad(9876543210UL, 5678901234UL, 9101112134UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_float() { TestUtils.AreEqual(-42660f, mad(-123.45f, 345.6f, 4.321f), 1, false); @@ -3540,27 +3540,27 @@ public static void mad_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), mad(-123.45f, 345.6f, TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_float2() { TestUtils.AreEqual(float2(-42660f, TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, TestUtils.SignedFloatQNaN()), float2(345.6f, 345.6f), float2(4.321f, 4.321f)), 1, false); TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, -123.45f), float2(TestUtils.SignedFloatQNaN(), 345.6f), float2(4.321f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_float3() { TestUtils.AreEqual(float3(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f), float3(345.6f, 345.6f, TestUtils.SignedFloatQNaN()), float3(4.321f, 4.321f, 4.321f)), 1, false); TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_float4() { TestUtils.AreEqual(float4(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float4(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f, -123.45f), float4(345.6f, 345.6f, TestUtils.SignedFloatQNaN(), 345.6f), float4(4.321f, 4.321f, 4.321f, TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_double() { TestUtils.AreEqual(-42659.999, mad(-123.45, 345.6, 4.321), 1, false); @@ -3569,27 +3569,27 @@ public static void mad_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), mad(-123.45, 345.6, TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_double2() { TestUtils.AreEqual(double2(-42659.999, TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, TestUtils.SignedDoubleQNaN()), double2(345.6, 345.6), double2(4.321, 4.321)), 1, false); TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, -123.45), double2(TestUtils.SignedDoubleQNaN(), 345.6), double2(4.321, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_double3() { TestUtils.AreEqual(double3(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, TestUtils.SignedDoubleQNaN(), -123.45), double3(345.6, 345.6, TestUtils.SignedDoubleQNaN()), double3(4.321, 4.321, 4.321)), 1, false); TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void mad_double4() { TestUtils.AreEqual(double4(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double4(-123.45, TestUtils.SignedDoubleQNaN(), -123.45, -123.45), double4(345.6, 345.6, TestUtils.SignedDoubleQNaN(), 345.6), double4(4.321, 4.321, 4.321, TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_float() { TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(float.NegativeInfinity, float.NegativeInfinity), 1, false); @@ -3643,7 +3643,7 @@ public static void fmod_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_float2() { TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), -323.4f), fmod(float2(float.NegativeInfinity, -323.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3673,7 +3673,7 @@ public static void fmod_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_float3() { TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero()), fmod(float3(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3695,7 +3695,7 @@ public static void fmod_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_float4() { TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero(), 0f), fmod(float4(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3713,7 +3713,7 @@ public static void fmod_float4() TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_double() { TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(double.NegativeInfinity, double.NegativeInfinity), 1, false); @@ -3767,7 +3767,7 @@ public static void fmod_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_double2() { TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), -323.4), fmod(double2(double.NegativeInfinity, -323.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -3797,7 +3797,7 @@ public static void fmod_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_double3() { TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero()), fmod(double3(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -3819,7 +3819,7 @@ public static void fmod_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void fmod_double4() { TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero(), 0.0), fmod(double4(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -3837,7 +3837,7 @@ public static void fmod_double4() TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_float() { TestUtils.AreEqual(0f, pow(float.NegativeInfinity, float.NegativeInfinity), 1, false); @@ -3887,7 +3887,7 @@ public static void pow_float() TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), pow(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_float2() { TestUtils.AreEqual(float2(0f, 0f), pow(float2(float.NegativeInfinity, -3.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3915,7 +3915,7 @@ public static void pow_float2() TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_float3() { TestUtils.AreEqual(float3(0f, 0f, float.PositiveInfinity), pow(float3(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3935,7 +3935,7 @@ public static void pow_float3() TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float3(3.4f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_float4() { TestUtils.AreEqual(float4(0f, 0f, float.PositiveInfinity, float.PositiveInfinity), pow(float4(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false); @@ -3952,7 +3952,7 @@ public static void pow_float4() TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_double() { TestUtils.AreEqual(0.0, pow(double.NegativeInfinity, double.NegativeInfinity), 1, false); @@ -4002,7 +4002,7 @@ public static void pow_double() TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), pow(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_double2() { TestUtils.AreEqual(double2(0.0, 0.0), pow(double2(double.NegativeInfinity, -3.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -4030,7 +4030,7 @@ public static void pow_double2() TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_double3() { TestUtils.AreEqual(double3(0.0, 0.0, double.PositiveInfinity), pow(double3(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -4050,7 +4050,7 @@ public static void pow_double3() TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double3(3.4, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void pow_double4() { TestUtils.AreEqual(double4(0.0, 0.0, double.PositiveInfinity, double.PositiveInfinity), pow(double4(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false); @@ -4067,7 +4067,7 @@ public static void pow_double4() TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_int() { TestUtils.AreEqual(0, ceilpow2(0)); @@ -4079,7 +4079,7 @@ public static void ceilpow2_int() TestUtils.AreEqual(0, ceilpow2(-2147483647)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_int2() { TestUtils.AreEqual(int2(0, 1), ceilpow2(int2(0, 1))); @@ -4088,7 +4088,7 @@ public static void ceilpow2_int2() TestUtils.AreEqual(int2(0, 0), ceilpow2(int2(-2147483647, -2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_int3() { TestUtils.AreEqual(int3(0, 1, 2), ceilpow2(int3(0, 1, 2))); @@ -4096,14 +4096,14 @@ public static void ceilpow2_int3() TestUtils.AreEqual(int3(0, 0, 0), ceilpow2(int3(-2147483647, -2147483647, -2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_int4() { TestUtils.AreEqual(int4(0, 1, 2, 4), ceilpow2(int4(0, 1, 2, 3))); TestUtils.AreEqual(int4(1073741824, -2147483648, 0, 0), ceilpow2(int4(1019642234, 1823423423, -2147483647, -2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_uint() { TestUtils.AreEqual(0u, ceilpow2(0u)); @@ -4115,7 +4115,7 @@ public static void ceilpow2_uint() TestUtils.AreEqual(0u, ceilpow2(4294967295u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_uint2() { TestUtils.AreEqual(uint2(0u, 1u), ceilpow2(uint2(0u, 1u))); @@ -4124,7 +4124,7 @@ public static void ceilpow2_uint2() TestUtils.AreEqual(uint2(0u, 0u), ceilpow2(uint2(4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_uint3() { TestUtils.AreEqual(uint3(0u, 1u, 2u), ceilpow2(uint3(0u, 1u, 2u))); @@ -4132,14 +4132,14 @@ public static void ceilpow2_uint3() TestUtils.AreEqual(uint3(0u, 0u, 0u), ceilpow2(uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_uint4() { TestUtils.AreEqual(uint4(0u, 1u, 2u, 4u), ceilpow2(uint4(0u, 1u, 2u, 3u))); TestUtils.AreEqual(uint4(1073741824u, 2147483648u, 0u, 0u), ceilpow2(uint4(1019642234u, 1823423423u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_long() { TestUtils.AreEqual(0L, ceilpow2(0L)); @@ -4155,7 +4155,7 @@ public static void ceilpow2_long() TestUtils.AreEqual(0L, ceilpow2(-100L)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceilpow2_ulong() { TestUtils.AreEqual(0UL, ceilpow2(0UL)); @@ -4171,7 +4171,7 @@ public static void ceilpow2_ulong() TestUtils.AreEqual(0UL, ceilpow2(10223372036854775808UL)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_int() { TestUtils.AreEqual(0, floorlog2(1)); @@ -4185,7 +4185,7 @@ public static void floorlog2_int() TestUtils.AreEqual(30, floorlog2(2147483647)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_int2() { TestUtils.AreEqual(int2(0, 1), floorlog2(int2(1, 2))); @@ -4195,7 +4195,7 @@ public static void floorlog2_int2() TestUtils.AreEqual(int2(30, 30), floorlog2(int2(2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_int3() { TestUtils.AreEqual(int3(0, 1, 1), floorlog2(int3(1, 2, 3))); @@ -4203,7 +4203,7 @@ public static void floorlog2_int3() TestUtils.AreEqual(int3(15, 15, 30), floorlog2(int3(32768, 32769, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_int4() { TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(int4(1, 2, 3, 4))); @@ -4211,7 +4211,7 @@ public static void floorlog2_int4() TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_uint() { TestUtils.AreEqual(0, floorlog2(1u)); @@ -4225,7 +4225,7 @@ public static void floorlog2_uint() TestUtils.AreEqual(30, floorlog2(2147483647u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_uint2() { TestUtils.AreEqual(int2(0, 1), floorlog2(uint2(1u, 2u))); @@ -4235,7 +4235,7 @@ public static void floorlog2_uint2() TestUtils.AreEqual(int2(30, 30), floorlog2(uint2(2147483647u, 2147483647u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_uint3() { TestUtils.AreEqual(int3(0, 1, 1), floorlog2(uint3(1u, 2u, 3u))); @@ -4243,7 +4243,7 @@ public static void floorlog2_uint3() TestUtils.AreEqual(int3(15, 15, 30), floorlog2(uint3(32768u, 32769u, 2147483647u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void floorlog2_uint4() { TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(uint4(1u, 2u, 3u, 4u))); @@ -4251,7 +4251,7 @@ public static void floorlog2_uint4() TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(uint4(2147483647u, 2147483647u, 2147483647u, 2147483647u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_int() { TestUtils.AreEqual(0, ceillog2(1)); @@ -4269,7 +4269,7 @@ public static void ceillog2_int() TestUtils.AreEqual(31, ceillog2(2147483647)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_int2() { TestUtils.AreEqual(int2(0, 1), ceillog2(int2(1, 2))); @@ -4281,7 +4281,7 @@ public static void ceillog2_int2() TestUtils.AreEqual(int2(31, 31), ceillog2(int2(2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_int3() { TestUtils.AreEqual(int3(0, 1, 2), ceillog2(int3(1, 2, 3))); @@ -4291,7 +4291,7 @@ public static void ceillog2_int3() TestUtils.AreEqual(int3(31, 31, 31), ceillog2(int3(2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_int4() { TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(int4(1, 2, 3, 4))); @@ -4300,7 +4300,7 @@ public static void ceillog2_int4() TestUtils.AreEqual(int4(31, 31, 31, 31), ceillog2(int4(2147483647, 2147483647, 2147483647, 2147483647))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_uint() { TestUtils.AreEqual(0, ceillog2(1u)); @@ -4318,7 +4318,7 @@ public static void ceillog2_uint() TestUtils.AreEqual(32, ceillog2(4294967295u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_uint2() { TestUtils.AreEqual(int2(0, 1), ceillog2(uint2(1u, 2u))); @@ -4330,7 +4330,7 @@ public static void ceillog2_uint2() TestUtils.AreEqual(int2(32, 32), ceillog2(uint2(4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_uint3() { TestUtils.AreEqual(int3(0, 1, 2), ceillog2(uint3(1u, 2u, 3u))); @@ -4340,7 +4340,7 @@ public static void ceillog2_uint3() TestUtils.AreEqual(int3(32, 32, 32), ceillog2(uint3(4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ceillog2_uint4() { TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(uint4(1u, 2u, 3u, 4u))); @@ -4349,7 +4349,7 @@ public static void ceillog2_uint4() TestUtils.AreEqual(int4(32, 32, 32, 32), ceillog2(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_int() { TestUtils.AreEqual(false, ispow2(-3)); @@ -4368,7 +4368,7 @@ public static void ispow2_int() TestUtils.AreEqual(false, ispow2(268431360)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_int2() { TestUtils.AreEqual(bool2(false, false), ispow2(int2(-3, -2))); @@ -4380,7 +4380,7 @@ public static void ispow2_int2() TestUtils.AreEqual(bool2(true, false), ispow2(int2(2097152, 268431360))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_int3() { TestUtils.AreEqual(bool3(false, false, false), ispow2(int3(-3, -2, -1))); @@ -4390,7 +4390,7 @@ public static void ispow2_int3() TestUtils.AreEqual(bool3(true, false, false), ispow2(int3(2097152, 268431360, 268431360))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_int4() { TestUtils.AreEqual(bool4(false, false, false, false), ispow2(int4(-3, -2, -1, 0))); @@ -4399,7 +4399,7 @@ public static void ispow2_int4() TestUtils.AreEqual(bool4(true, false, false, false), ispow2(int4(2097152, 268431360, 268431360, 268431360))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_uint() { TestUtils.AreEqual(false, ispow2(0u)); @@ -4416,7 +4416,7 @@ public static void ispow2_uint() TestUtils.AreEqual(false, ispow2(268431360u)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_uint2() { TestUtils.AreEqual(bool2(false, true), ispow2(uint2(0u, 1u))); @@ -4427,7 +4427,7 @@ public static void ispow2_uint2() TestUtils.AreEqual(bool2(false, false), ispow2(uint2(2097153u, 268431360u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_uint3() { TestUtils.AreEqual(bool3(false, true, true), ispow2(uint3(0u, 1u, 2u))); @@ -4436,7 +4436,7 @@ public static void ispow2_uint3() TestUtils.AreEqual(bool3(true, false, false), ispow2(uint3(2097152u, 2097153u, 268431360u))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ispow2_uint4() { TestUtils.AreEqual(bool4(false, true, true, false), ispow2(uint4(0u, 1u, 2u, 3u))); diff --git a/src/Tests/Tests/Shared/TestMatrix.cs b/src/Tests/Tests/Shared/TestMatrix.cs index 5fc6a37b..558ce482 100644 --- a/src/Tests/Tests/Shared/TestMatrix.cs +++ b/src/Tests/Tests/Shared/TestMatrix.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestMatrix { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_constructor_columns() { float2x2 a = float2x2(float2(1.0f, 2.0f), @@ -19,7 +19,7 @@ public static void float2x2_constructor_columns() TestUtils.AreEqual(4.0f, a.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_constructor_columns() { float3x3 a = float3x3(float3(1.0f, 2.0f, 3.0f), @@ -37,7 +37,7 @@ public static void float3x3_constructor_columns() TestUtils.AreEqual(9.0f, a.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_constructor_columns() { float4x4 a = float4x4(float4( 1.0f, 2.0f, 3.0f, 4.0f), @@ -63,7 +63,7 @@ public static void float4x4_constructor_columns() TestUtils.AreEqual(16.0f, a.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_constructor_scalars() { float2x2 a = float2x2(1.0f, 2.0f, @@ -75,7 +75,7 @@ public static void float2x2_constructor_scalars() TestUtils.AreEqual(4.0f, a.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_constructor_scalars() { float3x3 a = float3x3(1.0f, 2.0f, 3.0f, @@ -93,7 +93,7 @@ public static void float3x3_constructor_scalars() TestUtils.AreEqual(9.0f, a.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_constructor_scalars() { float4x4 a = float4x4( 1.0f, 2.0f, 3.0f, 4.0f, @@ -119,7 +119,7 @@ public static void float4x4_constructor_scalars() TestUtils.AreEqual(16.0f, a.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_constructor_float3x3() { float3x3 rot = float3x3(1.0f, 2.0f, 3.0f, @@ -136,7 +136,7 @@ public static void float4x4_constructor_float3x3() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_constructor_quaternion() { float3x3 m = float3x3(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f))); @@ -148,7 +148,7 @@ public static void float3x3_constructor_quaternion() TestUtils.AreEqual(r, m, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_constructor_quaternion_position() { float4x4 m = float4x4(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)), float3(1.0f, 2.0f, 3.0f)); @@ -161,7 +161,7 @@ public static void float4x4_constructor_quaternion_position() TestUtils.AreEqual(r, m, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_identity() { float2x2 a = float2x2.identity; @@ -171,7 +171,7 @@ public static void float2x2_identity() TestUtils.AreEqual(1.0f, a.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_identity() { float3x3 a = float3x3.identity; @@ -186,7 +186,7 @@ public static void float3x3_identity() TestUtils.AreEqual(1.0f, a.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_identity() { float4x4 a = float4x4.identity; @@ -208,7 +208,7 @@ public static void float4x4_identity() TestUtils.AreEqual(1.0f, a.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_rotate() { float epsilon = 0.0001f; @@ -220,7 +220,7 @@ public static void float2x2_rotate() TestUtils.AreEqual(cos(angle), m.c1.y, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_axis_angle() { float3 axis = normalize(float3(1.1f, 2.3f, -3.6f)); @@ -231,7 +231,7 @@ public static void float3x3_axis_angle() TestUtils.AreEqual(r, m, 0.00001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_axis_angle_consistency() { TestUtils.AreEqual(float3x3.RotateX(1.0f), float3x3.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f); @@ -239,7 +239,7 @@ public static void float3x3_axis_angle_consistency() TestUtils.AreEqual(float3x3.RotateZ(1.0f), float3x3.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_rotate_x() { float epsilon = 0.0001f; @@ -256,7 +256,7 @@ public static void float3x3_rotate_x() TestUtils.AreEqual(cos(angle), m.c2.z, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_rotate_y() { float epsilon = 0.0001f; @@ -273,7 +273,7 @@ public static void float3x3_rotate_y() TestUtils.AreEqual(cos(angle), m.c2.z, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_rotate_z() { float epsilon = 0.0001f; @@ -290,7 +290,7 @@ public static void float3x3_rotate_z() TestUtils.AreEqual(1.0f, m.c2.z, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_rotate_x_handedness() { float3 a = float3(0.0f, 0.3f, 0.7f); @@ -301,7 +301,7 @@ public static void float3x3_rotate_x_handedness() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_rotate_y_handedness() { float3 a = float3(0.3f, 0.0f, 0.7f); @@ -311,7 +311,7 @@ public static void float3x3_rotate_y_handedness() TestUtils.AreEqual(w > 0.0f, true); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_rotate_z_handedness() { float3 a = float3(0.3f, 0.7f, 0.0f); @@ -321,7 +321,7 @@ public static void float3x3_rotate_z_handedness() TestUtils.AreEqual(w > 0.0f, true); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_axis_angle() { float3 axis = normalize(float3(1.1f, 2.3f, -3.6f)); @@ -332,7 +332,7 @@ public static void float4x4_axis_angle() TestUtils.AreEqual(r, m, 0.00001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_axis_angle_consistency() { TestUtils.AreEqual(float4x4.RotateX(1.0f), float4x4.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f); @@ -340,7 +340,7 @@ public static void float4x4_axis_angle_consistency() TestUtils.AreEqual(float4x4.RotateZ(1.0f), float4x4.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_rotate_x() { float epsilon = 0.0001f; @@ -364,7 +364,7 @@ public static void float4x4_rotate_x() TestUtils.AreEqual(1.0f, m.c3.w, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_rotate_y() { float epsilon = 0.0001f; @@ -388,7 +388,7 @@ public static void float4x4_rotate_y() TestUtils.AreEqual(1.0f, m.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_rotate_z() { float epsilon = 0.0001f; @@ -412,7 +412,7 @@ public static void float4x4_rotate_z() TestUtils.AreEqual(1.0f, m.c3.w, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_rotate_x_handedness() { float3 a = float3(0.0f, 0.3f, 0.7f); @@ -423,7 +423,7 @@ public static void float4x4_rotate_x_handedness() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_rotate_y_handedness() { float3 a = float3(0.3f, 0.0f, 0.7f); @@ -433,7 +433,7 @@ public static void float4x4_rotate_y_handedness() TestUtils.AreEqual(w > 0.0f, true); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_rotate_z_handedness() { float3 a = float3(0.3f, 0.7f, 0.0f); @@ -480,7 +480,7 @@ public static void float4x4_rotate_z_handedness() static internal readonly float4x4 test4x4_zyx = new float4x4(test3x3_zyx, new float3(0, 0, 0)); - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_euler() { float3x3 m0_xyz = float3x3.EulerXYZ(test_angles); @@ -547,7 +547,7 @@ public static void float3x3_euler() TestUtils.AreEqual(test3x3_zyx, m3_zyx, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_euler() { float4x4 m0_xyz = float4x4.EulerXYZ(test_angles); @@ -614,7 +614,7 @@ public static void float4x4_euler() TestUtils.AreEqual(test4x4_zyx, m3_zyx, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_scale() { float2x2 m = float2x2(1.0f, 2.0f, @@ -635,7 +635,7 @@ public static void float2x2_scale() TestUtils.AreEqual(r1, c); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_scale() { float3x3 m = float3x3(1.0f, 2.0f, 3.0f, @@ -661,7 +661,7 @@ public static void float3x3_scale() TestUtils.AreEqual(r1, c); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_scale() { float4x4 m = float4x4( 1.0f, 2.0f, 3.0f, 4.0f, @@ -688,7 +688,7 @@ public static void float4x4_scale() TestUtils.AreEqual(r1, c); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_matrix_mul() { // http://www.wolframalpha.com/input/?i=%5B%5B1,2%5D,%5B3,4%5D%5D*%5B%5B21,22%5D,%5B23,24%5D%5D @@ -706,7 +706,7 @@ public static void float2x2_matrix_mul() TestUtils.AreEqual(162.0f, c.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_matrix_mul() { // http://www.wolframalpha.com/input/?i=%5B%5B1,2,3%5D,%5B4,5,6%5D,%5B7,8,9%5D%5D*%5B%5B21,22,23%5D,%5B24,25,26%5D,%5B27,28,29%5D%5D @@ -732,7 +732,7 @@ public static void float3x3_matrix_mul() TestUtils.AreEqual(630.0f, c.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_matrix_mul() { // https://fogbugz.unity3d.com/f/cases/1041176/ @@ -769,7 +769,7 @@ public static void float4x4_matrix_mul() TestUtils.AreEqual(1760.0f, c.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_transpose() { float2x2 a = float2x2(1.0f, 2.0f, @@ -783,7 +783,7 @@ public static void float2x2_transpose() TestUtils.AreEqual(4.0f, b.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_transpose() { float3x3 a = float3x3(1.0f, 2.0f, 3.0f, @@ -803,7 +803,7 @@ public static void float3x3_transpose() TestUtils.AreEqual(9.0f, b.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_transpose() { float4x4 a = float4x4( 1.0f, 2.0f, 3.0f, 4.0f, @@ -831,7 +831,7 @@ public static void float4x4_transpose() TestUtils.AreEqual(16.0f, b.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_inverse() { float2x2 a = float2x2( 0.542968f, 0.867379f, @@ -850,7 +850,7 @@ public static void float2x2_inverse() TestUtils.AreEqual(r.c1.y, invA.c1.y, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_inverse() { float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f, @@ -877,7 +877,7 @@ public static void float3x3_inverse() TestUtils.AreEqual(r.c2.z, invA.c2.z, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_inverse() { float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f,-0.943083f, @@ -914,7 +914,7 @@ public static void float4x4_inverse() TestUtils.AreEqual(r.c3.w, invA.c3.w, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x4_fastinverse() { float4x4 a = test4x4_xyz; @@ -931,7 +931,7 @@ public static void float3x4_fastinverse() TestUtils.AreEqual(invA.c3.xyz, fastInvB.c3.xyz, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_fastinverse() { float4x4 a = test4x4_xyz; @@ -943,7 +943,7 @@ public static void float4x4_fastinverse() TestUtils.AreEqual(invA, fastInvA, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2x2_determinant() { float2x2 a = float2x2(0.542968f, 0.867379f, @@ -953,7 +953,7 @@ public static void float2x2_determinant() TestUtils.AreEqual(-0.2610378f, det, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_determinant() { float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f, @@ -964,7 +964,7 @@ public static void float3x3_determinant() TestUtils.AreEqual(0.06019618f, det, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_determinant() { float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f, -0.943083f, @@ -976,7 +976,7 @@ public static void float4x4_determinant() TestUtils.AreEqual(0.5838502f, det, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_look_rotation() { float3 forward0 = normalize(float3(1.0f, 2.0f, 3.0f)); @@ -1012,7 +1012,7 @@ public static void float3x3_look_rotation() TestUtils.AreEqual(float3x3(quaternion.LookRotation(forward3, up3)), m3, 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_look_rotation_safe() { float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f; @@ -1029,7 +1029,7 @@ public static void float3x3_look_rotation_safe() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_lookat() { float4x4 m = float4x4.LookAt(float3(0.3f, -0.5f, 3.0f), float3(3.2f, -3.1f, 0.2f), normalize(float3(0.3f, 1.0f, -3.0f))); @@ -1043,7 +1043,7 @@ public static void float4x4_lookat() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_ortho() { float4x4 m = float4x4.Ortho(2.0f, 3.0f, -3.0f, 7.0f); @@ -1056,7 +1056,7 @@ public static void float4x4_ortho() TestUtils.AreEqual(r, m, 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_orthoOffCenter() { float4x4 m = float4x4.OrthoOffCenter(-2.0f, 1.0f, -3.0f, -1.0f, -3.0f, 7.0f); @@ -1069,7 +1069,7 @@ public static void float4x4_orthoOffCenter() TestUtils.AreEqual(r, m, 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_perspective() { float fovy = 1.6f; @@ -1098,7 +1098,7 @@ public static void float4x4_perspective() TestUtils.AreEqual(float3(1.0f, 1.0f, 1.0f), pp1.xyz, 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_perspectiveOffCenter() { float fovy = 1.6f; @@ -1132,7 +1132,7 @@ public static void float4x4_perspectiveOffCenter() TestUtils.AreEqual(float3(-1.0f, 1.0f, 1.0f), pp2.xyz, 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4x4_TRS() { float3 scale = float3(1.2f, -0.4f, 2.3f); @@ -1143,7 +1143,7 @@ public static void float4x4_TRS() TestUtils.AreEqual(r0, m0, 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_constructor_float4x4() { var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16)); @@ -1152,7 +1152,7 @@ public static void float3x3_constructor_float4x4() TestUtils.AreEqual(expected, new float3x3(f4x4)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_explicit_cast_float4x4() { var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16)); @@ -1161,7 +1161,7 @@ public static void float3x3_explicit_cast_float4x4() TestUtils.AreEqual(expected, (float3x3)f4x4); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_from_float4x4_without_new() { var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16)); @@ -1170,7 +1170,7 @@ public static void float3x3_from_float4x4_without_new() TestUtils.AreEqual(expected, float3x3(f4x4)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_pseudoinverse_non_singular() { const float kTolerance = 1e-5f; @@ -1191,7 +1191,7 @@ public static void float3x3_pseudoinverse_non_singular() TestUtils.AreEqual(expected, inverse(a), kTolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3x3_pseudoinverse_singular() { const float kTolerance = 1e-5f; diff --git a/src/Tests/Tests/Shared/TestMinMaxAABB.cs b/src/Tests/Tests/Shared/TestMinMaxAABB.cs index a08e52cd..7c5c5e8c 100644 --- a/src/Tests/Tests/Shared/TestMinMaxAABB.cs +++ b/src/Tests/Tests/Shared/TestMinMaxAABB.cs @@ -9,7 +9,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestMinMaxAABB { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_trivial() { var aabb = new MinMaxAABB(); @@ -18,7 +18,7 @@ public static void Encapsulate_float3_trivial() TestUtils.AreEqual(float3.zero, aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_max() { var aabb = new MinMaxAABB(); @@ -27,7 +27,7 @@ public static void Encapsulate_float3_new_max() TestUtils.AreEqual(new float3(1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_min() { var aabb = new MinMaxAABB(); @@ -36,7 +36,7 @@ public static void Encapsulate_float3_new_min() TestUtils.AreEqual(new float3(-1.0f), aabb.Min); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_minx_maxyz() { var aabb = new MinMaxAABB(); @@ -45,7 +45,7 @@ public static void Encapsulate_float3_new_minx_maxyz() TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_minxy_maxz() { var aabb = new MinMaxAABB(); @@ -54,7 +54,7 @@ public static void Encapsulate_float3_new_minxy_maxz() TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_minxz_maxy() { var aabb = new MinMaxAABB(); @@ -63,7 +63,7 @@ public static void Encapsulate_float3_new_minxz_maxy() TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_minz_maxxy() { var aabb = new MinMaxAABB(); @@ -72,7 +72,7 @@ public static void Encapsulate_float3_new_minz_maxxy() TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_float3_new_miny_maxxz() { var aabb = new MinMaxAABB(); @@ -81,7 +81,7 @@ public static void Encapsulate_float3_new_miny_maxxz() TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_trivial() { var aabb = new MinMaxAABB(); @@ -90,7 +90,7 @@ public static void Encapsulate_MinMaxAABB_trivial() TestUtils.AreEqual(float3.zero, aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_max() { var aabb = new MinMaxAABB(); @@ -100,7 +100,7 @@ public static void Encapsulate_MinMaxAABB_new_max() TestUtils.AreEqual(p, aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_min() { var aabb = new MinMaxAABB(); @@ -110,7 +110,7 @@ public static void Encapsulate_MinMaxAABB_new_min() TestUtils.AreEqual(p, aabb.Min); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_minx_maxyz() { var aabb = new MinMaxAABB(); @@ -119,7 +119,7 @@ public static void Encapsulate_MinMaxAABB_new_minx_maxyz() TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_minxy_maxz() { var aabb = new MinMaxAABB(); @@ -128,7 +128,7 @@ public static void Encapsulate_MinMaxAABB_new_minxy_maxz() TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_minxz_maxy() { var aabb = new MinMaxAABB(); @@ -137,7 +137,7 @@ public static void Encapsulate_MinMaxAABB_new_minxz_maxy() TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_minz_maxxy() { var aabb = new MinMaxAABB(); @@ -146,7 +146,7 @@ public static void Encapsulate_MinMaxAABB_new_minz_maxxy() TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Encapsulate_MinMaxAABB_new_miny_maxxz() { var aabb = new MinMaxAABB(); @@ -155,14 +155,14 @@ public static void Encapsulate_MinMaxAABB_new_miny_maxxz() TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_trivial() { MinMaxAABB aabb = new MinMaxAABB(); TestUtils.IsTrue(aabb.Equals(aabb)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals() { MinMaxAABB aabb1 = new MinMaxAABB { Min = new float3(-123.0f, 0.5182f, 20.0f), Max = new float3(1.0f, -1.0f, 0.99191f) }; @@ -171,7 +171,7 @@ public static void Equals() TestUtils.IsTrue(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_diff_minx() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -180,7 +180,7 @@ public static void Equals_diff_minx() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_diff_miny() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -189,7 +189,7 @@ public static void Equals_diff_miny() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_diff_minz() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -198,7 +198,7 @@ public static void Equals_diff_minz() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_diff_maxx() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -207,7 +207,7 @@ public static void Equals_diff_maxx() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_diff_maxy() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -216,7 +216,7 @@ public static void Equals_diff_maxy() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Equals_diff_maxz() { MinMaxAABB aabb1 = new MinMaxAABB(); @@ -225,7 +225,7 @@ public static void Equals_diff_maxz() TestUtils.IsFalse(aabb2.Equals(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void SurfaceArea() { var min = new float3(-47.989063262939453125f, 28.037994384765625f, -9.756519317626953125f); @@ -235,7 +235,7 @@ public static void SurfaceArea() TestUtils.AreEqual(14400.470703125f, aabb.SurfaceArea, 1, true); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Extents() { var min = new float3(48.152984619140625f, -33.58978271484375f, -37.498805999755859375f); @@ -246,7 +246,7 @@ public static void Extents() TestUtils.AreEqual(expected, aabb.Extents); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Center() { var min = new float3(47.902675628662109375f, -34.302494049072265625f, 22.7147884368896484375f); @@ -257,7 +257,7 @@ public static void Center() TestUtils.AreEqual(expected, aabb.Center); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void HalfExtents() { var min = new float3(-14.3485383987426757813f, 28.68161773681640625f, -40.28060150146484375f); @@ -268,7 +268,7 @@ public static void HalfExtents() TestUtils.AreEqual(expected, aabb.HalfExtents); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Constructor() { var min = new float3(38.95940399169921875f, -24.644245147705078125f, 27.7903194427490234375f); @@ -279,7 +279,7 @@ public static void Constructor() TestUtils.AreEqual(max, aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ContainsPoint() { var aabb = new MinMaxAABB(new float3(-1), new float3(1)); @@ -301,7 +301,7 @@ public static void ContainsPoint() TestUtils.IsFalse(aabb.Contains(new float3(-1.0f, -1.0f, -1.0f - EPSILON))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ContainsAabb_Trivial() { var aabb1 = new MinMaxAABB(); @@ -311,7 +311,7 @@ public static void ContainsAabb_Trivial() TestUtils.IsTrue(aabb2.Contains(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ContainsAabb() { var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -321,7 +321,7 @@ public static void ContainsAabb() TestUtils.IsFalse(aabb2.Contains(aabb1)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ContainsAabb_BarelyNotContained() { var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -340,7 +340,7 @@ public static void ContainsAabb_BarelyNotContained() TestUtils.IsFalse(aabb1.Contains(aabb7)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Overlap_Trivial() { var aabb = new MinMaxAABB(); @@ -348,7 +348,7 @@ public static void Overlap_Trivial() TestUtils.IsTrue(aabb.Overlaps(aabb)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Overlap_Corner() { var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -389,7 +389,7 @@ public static void Overlap_Corner() TestUtils.IsTrue(cornerAabb8.Overlaps(aabb)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void NoOverlap_Corner() { var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f)); @@ -430,7 +430,7 @@ public static void NoOverlap_Corner() TestUtils.IsFalse(cornerAabb8.Overlaps(aabb)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Expand_PositiveDistance() { var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f)); @@ -440,7 +440,7 @@ public static void Expand_PositiveDistance() TestUtils.AreEqual(new float3(1.5f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Expand_NegativeDistance() { var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f)); @@ -450,7 +450,7 @@ public static void Expand_NegativeDistance() TestUtils.AreEqual(new float3(-0.5f), aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CreateFromCenterAndExtents() { var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f); @@ -463,7 +463,7 @@ public static void CreateFromCenterAndExtents() TestUtils.AreEqual(expectedMax, aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CreateFromCenterAndHalfExtents() { var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f); @@ -476,14 +476,14 @@ public static void CreateFromCenterAndHalfExtents() TestUtils.AreEqual(expectedMax, aabb.Max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void IsValid_Trivial() { TestUtils.IsTrue(new MinMaxAABB().IsValid); TestUtils.IsFalse(new MinMaxAABB(new float3(1.0f), new float3(-1.0f)).IsValid); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void IsValid_OneComponentInvalid() { TestUtils.IsFalse(new MinMaxAABB(float3.zero, new float3(-1.0f, 0.0f, 0.0f)).IsValid); @@ -494,7 +494,7 @@ public static void IsValid_OneComponentInvalid() TestUtils.IsFalse(new MinMaxAABB(new float3(0.0f, 0.0f, 1.0f), float3.zero).IsValid); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Transform_RigidTransform() { var t = new RigidTransform(quaternion.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f)); @@ -507,7 +507,7 @@ public static void Transform_RigidTransform() TestUtils.AreEqual(expectedMax, aabb.Max, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Transform_float4x4() { var t = new float4x4(float3x3.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f)); @@ -520,7 +520,7 @@ public static void Transform_float4x4() TestUtils.AreEqual(expectedMax, aabb.Max, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Transform_float3x3() { var t = float3x3.EulerXYZ(PI * 0.25f); diff --git a/src/Tests/Tests/Shared/TestPlane.cs b/src/Tests/Tests/Shared/TestPlane.cs index c79ecb0b..2fbd3251 100644 --- a/src/Tests/Tests/Shared/TestPlane.cs +++ b/src/Tests/Tests/Shared/TestPlane.cs @@ -10,7 +10,7 @@ public class TestPlane // An arbitrary tolerance. const float Tolerance = 0.0000025f; - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Empty() { var p = new Plane(); @@ -20,7 +20,7 @@ public static void Empty() TestUtils.AreEqual(0.0f, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void GetNormal() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -28,7 +28,7 @@ public static void GetNormal() TestUtils.AreEqual(new float3(1.0f, 2.0f, 3.0f), p.Normal); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void GetDistance() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -36,7 +36,7 @@ public static void GetDistance() TestUtils.AreEqual(4.0f, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void SetNormal() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -45,7 +45,7 @@ public static void SetNormal() TestUtils.AreEqual(new float3(-1.0f, -2.0f, -3.0f), p.Normal); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void SetDistance() { var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) }; @@ -54,7 +54,7 @@ public static void SetDistance() TestUtils.AreEqual(-4.0f, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithNormalAndDistance() { var n = math.normalize(new float3(4.0f, -5.0f, 6.0f)); @@ -66,7 +66,7 @@ public static void ConstructWithNormalAndDistance() TestUtils.AreEqual(d, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithCoefficients_NonUnitLengthNormal() { var abcd = new float4(4.0f, -5.0f, 6.0f, 123.0f); @@ -78,7 +78,7 @@ public static void ConstructWithCoefficients_NonUnitLengthNormal() TestUtils.AreEqual(expected.w, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithNormalAndPointInPlane_NegativeDistance() { var n = math.up(); @@ -90,7 +90,7 @@ public static void ConstructWithNormalAndPointInPlane_NegativeDistance() TestUtils.AreEqual(-1.0f, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithNormalAndPointInPlane_PositiveDistance() { var n = math.down(); @@ -102,7 +102,7 @@ public static void ConstructWithNormalAndPointInPlane_PositiveDistance() TestUtils.AreEqual(1.0f, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithNormalAndPointInPlane() { var normal = new float3(2.0f, 2.0f, 2.0f); @@ -116,7 +116,7 @@ public static void ConstructWithNormalAndPointInPlane() TestUtils.AreEqual(expectedD, p.Distance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithTwoVectorsAndOrigin_Trivial() { var v1 = new float3(1.0f, 0.0f, 0.0f); @@ -126,7 +126,7 @@ public static void ConstructWithTwoVectorsAndOrigin_Trivial() TestUtils.AreEqual(new float4(0.0f, 0.0f, 1.0f, 0.0f), p); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin() { var v1 = new float3(5.0f, 0.0f, 0.0f); @@ -136,7 +136,7 @@ public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin() TestUtils.AreEqual(new float4(0.0f, 0.0f, -1.0f, 1.0f), p); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void SignedDistanceToPoint() { var vInPlane1 = new float3(2.0f, 1.0f, -0.18f); @@ -152,7 +152,7 @@ public static void SignedDistanceToPoint() TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(pointInPlane - n), Tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void SignedDistanceToPointTrivial() { var p = new Plane(math.up(), 0.0f); @@ -174,7 +174,7 @@ public static void SignedDistanceToPointTrivial() TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(math.down() + math.forward())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ProjectionTrivial() { var p = new Plane(math.up(), 0.0f); @@ -183,7 +183,7 @@ public static void ProjectionTrivial() TestUtils.AreEqual(expected, p.Projection(math.up() + expected)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Projection() { var normal = new float3(1.0f); @@ -195,7 +195,7 @@ public static void Projection() TestUtils.AreEqual(expected, p.Projection(expected), math.EPSILON); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void Flipped() { var normal = new float3(1.0f); @@ -207,7 +207,7 @@ public static void Flipped() TestUtils.AreEqual(new float4(expectedN, expectedD), p.Flipped, Tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void ImplicitToFloat4() { var normal = new float3(1.1f, -20.0f, 15.182f); @@ -220,7 +220,7 @@ public static void ImplicitToFloat4() TestUtils.AreEqual(new float4(expectedN, expectedD), p_as_float4, Tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void NormalizeFloat4() { var p = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f); @@ -229,7 +229,7 @@ public static void NormalizeFloat4() TestUtils.AreEqual(expected, Plane.Normalize(p), Tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void NormalizePlane() { var p = new Plane { NormalAndDistance = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f) }; @@ -241,7 +241,7 @@ public static void NormalizePlane() TestUtils.AreEqual(expected.w, normalized.Distance, Tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CreateFromUnitNormalAndDistance() { var n = new float3(9.108767140247756e-02f, 3.966831912609620e-01f, 9.134251375397404e-01f); @@ -252,7 +252,7 @@ public static void CreateFromUnitNormalAndDistance() TestUtils.AreEqual(expected, p.NormalAndDistance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CreateFromUnitNormalAndPointInPlane() { var n = new float3(4.724920516359185e-01f, 1.444614284194820e-01f, 8.694148358751899e-01f); @@ -263,4 +263,4 @@ public static void CreateFromUnitNormalAndPointInPlane() TestUtils.AreEqual(expected, p.NormalAndDistance, Tolerance); } } -} \ No newline at end of file +} diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs index 0279de90..301725ee 100644 --- a/src/Tests/Tests/Shared/TestQuaternion.cs +++ b/src/Tests/Tests/Shared/TestQuaternion.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestQuaternion { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_basic_constructors() { quaternion q = quaternion(1.0f, 2.0f, 3.0f, 4.0f); @@ -23,7 +23,7 @@ public static void quaternion_basic_constructors() TestUtils.AreEqual(4.0f, q2.value.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_construct_from_matrix() { TestUtils.AreEqual(float3x3(quaternion(TestMatrix.test3x3_xyz)), TestMatrix.test3x3_xyz, 0.0001f); @@ -45,7 +45,7 @@ public static void quaternion_construct_from_matrix() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_construct_from_matrix3x3_torture() { Random rnd = new Random(0x12345678); @@ -58,7 +58,7 @@ public static void quaternion_construct_from_matrix3x3_torture() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_construct_from_matrix4x4_torture() { Random rnd = new Random(0x12345678); @@ -71,7 +71,7 @@ public static void quaternion_construct_from_matrix4x4_torture() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_axis_angle() { quaternion q = quaternion.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f); @@ -80,7 +80,7 @@ public static void quaternion_axis_angle() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_axis_angle_consistency() { TestUtils.AreEqual(quaternion.RotateX(1.0f), quaternion.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f); @@ -88,7 +88,7 @@ public static void quaternion_axis_angle_consistency() TestUtils.AreEqual(quaternion.RotateZ(1.0f), quaternion.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void euler_to_quaternion() { float3 test_angles = TestMatrix.test_angles; @@ -158,7 +158,7 @@ public static void euler_to_quaternion() TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotateX() { float angle = 2.3f; @@ -168,7 +168,7 @@ public static void quaternion_rotateX() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotateY() { float angle = 2.3f; @@ -178,7 +178,7 @@ public static void quaternion_rotateY() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotateZ() { float angle = 2.3f; @@ -193,7 +193,7 @@ public static void quaternion_rotateZ() static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f); static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f); - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_conjugate() { quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f); @@ -203,7 +203,7 @@ public static void quaternion_conjugate() TestUtils.AreEqual(r, cq); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_inverse() { quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f); @@ -213,7 +213,7 @@ public static void quaternion_inverse() TestUtils.AreEqual(quaternion.identity, qiq, 0.00001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_dot() { float dot01 = dot(test_q0, test_q1); @@ -223,7 +223,7 @@ public static void quaternion_dot() TestUtils.AreEqual(-0.5795583f, dot02, 0.00001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_nlerp() { quaternion r0 = nlerp(test_q0, test_q1, 0.3f); @@ -235,7 +235,7 @@ public static void quaternion_nlerp() TestUtils.AreEqual(quaternion(-0.4054004f, 0.06570576f, -0.7457358f, -0.5246059f), r2, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_slerp() { quaternion r0 = slerp(test_q0, test_q1, 0.3f); @@ -247,7 +247,7 @@ public static void quaternion_slerp() TestUtils.AreEqual(quaternion(0.2596942f, -0.4369303f, 0.7902023f, 0.34239f), r2, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_mul_vector() { float3x3 m = TestMatrix.test3x3_xyz; @@ -261,7 +261,7 @@ public static void quaternion_mul_vector() TestUtils.AreEqual(mvector, qvector, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_log_exp_identity() { quaternion q = quaternion(1.2f, -2.6f, 3.1f, 6.0f); @@ -270,7 +270,7 @@ public static void quaternion_log_exp_identity() TestUtils.AreEqual(q, exp_log_q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_log_exp_rotation() { quaternion q = quaternion(TestMatrix.test3x3_xyz); @@ -280,7 +280,7 @@ public static void quaternion_log_exp_rotation() TestUtils.AreEqual(q3, t, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_unitlog_unitexp_rotation() { quaternion q = quaternion(TestMatrix.test3x3_xyz); @@ -290,7 +290,7 @@ public static void quaternion_unitlog_unitexp_rotation() TestUtils.AreEqual(q3, t, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_look_rotation() { // Exercise the 4 cases @@ -319,7 +319,7 @@ public static void quaternion_look_rotation() TestUtils.AreEqual(float3x3.LookRotation(forward3, up3), float3x3(q3), 0.001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_look_rotation_safe() { float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f; @@ -381,7 +381,7 @@ public static void quaternion_angle() TestUtils.AreEqual(0f, angle); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_identity() { const float tolerance = 1e-5f; @@ -389,7 +389,7 @@ public static void quaternion_rotation_from_3x3_identity() TestUtils.AreEqual(quaternion.identity, q, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_with_uniform_scale() { const float tolerance = 1e-5f; @@ -401,7 +401,7 @@ public static void quaternion_rotation_from_3x3_with_uniform_scale() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_with_nonuniform_scale() { const float tolerance = 1e-5f; @@ -413,7 +413,7 @@ public static void quaternion_rotation_from_3x3_with_nonuniform_scale() TestUtils.AreEqual(quaternion.identity, q, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_with_negative_scale_x() { const float tolerance = 1e-5f; @@ -425,7 +425,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_x() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_with_negative_scale_y() { const float tolerance = 1e-5f; @@ -437,7 +437,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_y() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_with_negative_scale_z() { const float tolerance = 1e-5f; @@ -449,7 +449,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_z() TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale() { const float tolerance = 1e-5f; diff --git a/src/Tests/Tests/Shared/TestRigidTransform.cs b/src/Tests/Tests/Shared/TestRigidTransform.cs index eacec9ed..ac0d8060 100644 --- a/src/Tests/Tests/Shared/TestRigidTransform.cs +++ b/src/Tests/Tests/Shared/TestRigidTransform.cs @@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests [TestFixture] class TestRigidTransform { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_construct_from_matrix() { float4x4 m4x4 = TestMatrix.test4x4_zyx; @@ -19,7 +19,7 @@ public static void rigid_transform_construct_from_matrix() TestUtils.AreEqual(m4x4, mq4x4, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_axisAngle() { RigidTransform q = RigidTransform.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f); @@ -28,7 +28,7 @@ public static void rigid_transform_axisAngle() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_euler() { float3 test_angles = TestMatrix.test_angles; @@ -98,7 +98,7 @@ public static void rigid_transform_euler() TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_rotateX() { float angle = 2.3f; @@ -108,7 +108,7 @@ public static void rigid_transform_rotateX() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_rotateY() { float angle = 2.3f; @@ -118,7 +118,7 @@ public static void rigid_transform_rotateY() TestUtils.AreEqual(r, q, 0.0001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_rotateZ() { float angle = 2.3f; @@ -133,7 +133,7 @@ public static void rigid_transform_rotateZ() static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f); static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f); - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_inverse() { RigidTransform q = RigidTransform(quaternion(1.0f, -2.0f, 3.0f, -4.0f), float3(1,2,3)); @@ -143,7 +143,7 @@ public static void rigid_transform_inverse() TestUtils.AreEqual(RigidTransform.identity, qiq, 0.00001f); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void rigid_transform_mul_vector() { float4x4 m = TestMatrix.test4x4_xyz; diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs index db889bd9..e75cf04f 100644 --- a/src/Tests/Tests/Shared/TestSvd.cs +++ b/src/Tests/Tests/Shared/TestSvd.cs @@ -48,7 +48,7 @@ static void ValidatePenrose2(in float3x3 a, in float3x3 b) static void ValidateSingular(in float3x3 a) => TestUtils.AreEqual(0.0f, math.determinant(a), k_SVDTolerance); - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanSVDInverseNonSingularFloat3x3() { var mat = math.float3x3( @@ -71,7 +71,7 @@ public static void CanSVDInverseNonSingularFloat3x3() TestUtils.AreEqual(1f, testIdentity.c2.z, k_SVDTolerance); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanSVDInverseFloat3x3With_NullColumn() { var mat = math.float3x3( @@ -89,7 +89,7 @@ public static void CanSVDInverseFloat3x3With_NullColumn() ValidatePenrose2(inv, mat); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanSVDInverseFloat3x3With_NullRow() { var mat = math.float3x3( @@ -107,7 +107,7 @@ public static void CanSVDInverseFloat3x3With_NullRow() ValidatePenrose2(inv, mat); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanSVDInverseFloat3x3With_LinearDependentColumn() { var mat = math.float3x3( @@ -125,7 +125,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentColumn() ValidatePenrose2(inv, mat); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanSVDInverseFloat3x3With_LinearDependentRow() { var mat = math.float3x3( @@ -143,7 +143,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentRow() ValidatePenrose2(inv, mat); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanSVDInverseFloat3x3With_RotatedZeroScale() { var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f))); @@ -160,7 +160,7 @@ public static void CanSVDInverseFloat3x3With_RotatedZeroScale() } // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181() { var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f)); @@ -170,7 +170,7 @@ public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181() } // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY() { var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)); @@ -182,4 +182,4 @@ public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY() TestUtils.AreEqual(0.0f, math.length(m0.c0 - m1.c0), k_SVDTolerance); } } -} \ No newline at end of file +} diff --git a/src/Tests/Tests/Shared/TestUint2.gen.cs b/src/Tests/Tests/Shared/TestUint2.gen.cs index 04620a33..d853e034 100644 --- a/src/Tests/Tests/Shared/TestUint2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2.gen.cs @@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_zero() { TestUtils.AreEqual(0u, uint2.zero.x); TestUtils.AreEqual(0u, uint2.zero.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_constructor() { uint2 a = new uint2(1, 2); @@ -30,7 +30,7 @@ public static void uint2_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_scalar_constructor() { uint2 a = new uint2(17u); @@ -38,7 +38,7 @@ public static void uint2_scalar_constructor() TestUtils.AreEqual(17u, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_static_constructor() { uint2 a = uint2(1, 2); @@ -46,7 +46,7 @@ public static void uint2_static_constructor() TestUtils.AreEqual(2, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_static_scalar_constructor() { uint2 a = uint2(17u); @@ -54,7 +54,7 @@ public static void uint2_static_scalar_constructor() TestUtils.AreEqual(17u, a.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_equal_wide_wide() { uint2 a0 = uint2(2105871082, 35218899); @@ -78,7 +78,7 @@ public static void uint2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_equal_wide_scalar() { uint2 a0 = uint2(437822262, 2020661134); @@ -102,7 +102,7 @@ public static void uint2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -126,7 +126,7 @@ public static void uint2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_not_equal_wide_wide() { uint2 a0 = uint2(1977284100, 1293292704); @@ -150,7 +150,7 @@ public static void uint2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_not_equal_wide_scalar() { uint2 a0 = uint2(1038269360, 1427812625); @@ -174,7 +174,7 @@ public static void uint2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -198,7 +198,7 @@ public static void uint2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_less_wide_wide() { uint2 a0 = uint2(1486550609, 1779244308); @@ -222,7 +222,7 @@ public static void uint2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_less_wide_scalar() { uint2 a0 = uint2(796797557, 670113454); @@ -246,7 +246,7 @@ public static void uint2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -270,7 +270,7 @@ public static void uint2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_greater_wide_wide() { uint2 a0 = uint2(2087717754, 1725569452); @@ -294,7 +294,7 @@ public static void uint2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_greater_wide_scalar() { uint2 a0 = uint2(1208626274, 239697208); @@ -318,7 +318,7 @@ public static void uint2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -342,7 +342,7 @@ public static void uint2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_less_equal_wide_wide() { uint2 a0 = uint2(154092149, 1515170149); @@ -366,7 +366,7 @@ public static void uint2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_less_equal_wide_scalar() { uint2 a0 = uint2(1479531977, 1427983411); @@ -390,7 +390,7 @@ public static void uint2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -414,7 +414,7 @@ public static void uint2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_greater_equal_wide_wide() { uint2 a0 = uint2(8538378, 2131749726); @@ -438,7 +438,7 @@ public static void uint2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_greater_equal_wide_scalar() { uint2 a0 = uint2(2049236663, 182691143); @@ -462,7 +462,7 @@ public static void uint2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -486,7 +486,7 @@ public static void uint2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_add_wide_wide() { uint2 a0 = uint2(2135171378, 21433296); @@ -510,7 +510,7 @@ public static void uint2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_add_wide_scalar() { uint2 a0 = uint2(665815972, 1783729250); @@ -534,7 +534,7 @@ public static void uint2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -558,7 +558,7 @@ public static void uint2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_sub_wide_wide() { uint2 a0 = uint2(1410318491, 1097280168); @@ -582,7 +582,7 @@ public static void uint2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_sub_wide_scalar() { uint2 a0 = uint2(1508669340, 1594795463); @@ -606,7 +606,7 @@ public static void uint2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -630,7 +630,7 @@ public static void uint2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_mul_wide_wide() { uint2 a0 = uint2(61417577, 219585476); @@ -654,7 +654,7 @@ public static void uint2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_mul_wide_scalar() { uint2 a0 = uint2(871746615, 492532311); @@ -678,7 +678,7 @@ public static void uint2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -702,7 +702,7 @@ public static void uint2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_div_wide_wide() { uint2 a0 = uint2(333171510, 858154903); @@ -726,7 +726,7 @@ public static void uint2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_div_wide_scalar() { uint2 a0 = uint2(1433072926, 1073958635); @@ -750,7 +750,7 @@ public static void uint2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -774,7 +774,7 @@ public static void uint2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_mod_wide_wide() { uint2 a0 = uint2(258342924, 1454754891); @@ -798,7 +798,7 @@ public static void uint2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_mod_wide_scalar() { uint2 a0 = uint2(560988938, 629524514); @@ -822,7 +822,7 @@ public static void uint2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -846,7 +846,7 @@ public static void uint2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_plus() { uint2 a0 = uint2(195392567, 222719748); @@ -866,7 +866,7 @@ public static void uint2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_neg() { uint2 a0 = uint2(1385088677, 94114564); @@ -886,7 +886,7 @@ public static void uint2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_prefix_inc() { uint2 a0 = uint2(780471723, 954741756); @@ -906,7 +906,7 @@ public static void uint2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_postfix_inc() { uint2 a0 = uint2(241865086, 2145821641); @@ -926,7 +926,7 @@ public static void uint2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_prefix_dec() { uint2 a0 = uint2(1331961415, 1612382200); @@ -946,7 +946,7 @@ public static void uint2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_postfix_dec() { uint2 a0 = uint2(1870005937, 1708534798); @@ -966,7 +966,7 @@ public static void uint2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_and_wide_wide() { uint2 a0 = uint2(1055241304, 859321394); @@ -990,7 +990,7 @@ public static void uint2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_and_wide_scalar() { uint2 a0 = uint2(1513158868, 284695609); @@ -1014,7 +1014,7 @@ public static void uint2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1038,7 +1038,7 @@ public static void uint2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_or_wide_wide() { uint2 a0 = uint2(1920951869, 1750772852); @@ -1062,7 +1062,7 @@ public static void uint2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_or_wide_scalar() { uint2 a0 = uint2(1295304853, 1307252624); @@ -1086,7 +1086,7 @@ public static void uint2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1110,7 +1110,7 @@ public static void uint2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_xor_wide_wide() { uint2 a0 = uint2(1843655608, 362425681); @@ -1134,7 +1134,7 @@ public static void uint2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_xor_wide_scalar() { uint2 a0 = uint2(169345668, 176087064); @@ -1158,7 +1158,7 @@ public static void uint2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1182,7 +1182,7 @@ public static void uint2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_left_shift() { uint2 a0 = uint2(1129100049, 829482269); @@ -1206,7 +1206,7 @@ public static void uint2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_right_shift() { uint2 a0 = uint2(809126085, 908563670); @@ -1230,7 +1230,7 @@ public static void uint2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_operator_bitwise_not() { uint2 a0 = uint2(111796841, 603562399); @@ -1250,7 +1250,7 @@ public static void uint2_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_shuffle_result_1() { uint2 a = uint2(0, 1); @@ -1262,7 +1262,7 @@ public static void uint2_shuffle_result_1() TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_shuffle_result_2() { uint2 a = uint2(0, 1); @@ -1286,7 +1286,7 @@ public static void uint2_shuffle_result_2() TestUtils.AreEqual(uint2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_shuffle_result_3() { uint2 a = uint2(0, 1); @@ -1310,7 +1310,7 @@ public static void uint2_shuffle_result_3() TestUtils.AreEqual(uint3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_shuffle_result_4() { uint2 a = uint2(0, 1); diff --git a/src/Tests/Tests/Shared/TestUint2x2.gen.cs b/src/Tests/Tests/Shared/TestUint2x2.gen.cs index dd8ed7a4..012db8aa 100644 --- a/src/Tests/Tests/Shared/TestUint2x2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_zero() { TestUtils.AreEqual(0u, uint2x2.zero.c0.x); @@ -24,7 +24,7 @@ public static void uint2x2_zero() TestUtils.AreEqual(0u, uint2x2.zero.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_identity() { TestUtils.AreEqual(1u, uint2x2.identity.c0.x); @@ -33,7 +33,7 @@ public static void uint2x2_identity() TestUtils.AreEqual(1u, uint2x2.identity.c1.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_equal_wide_wide() { uint2x2 a0 = uint2x2(2105871082, 35218899, 1550755093, 764676020); @@ -57,7 +57,7 @@ public static void uint2x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_equal_wide_scalar() { uint2x2 a0 = uint2x2(437822262, 2020661134, 541786900, 853113810); @@ -81,7 +81,7 @@ public static void uint2x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -105,7 +105,7 @@ public static void uint2x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_not_equal_wide_wide() { uint2x2 a0 = uint2x2(1977284100, 1293292704, 1547283851, 422428953); @@ -129,7 +129,7 @@ public static void uint2x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_not_equal_wide_scalar() { uint2x2 a0 = uint2x2(1038269360, 1427812625, 103361237, 1347017023); @@ -153,7 +153,7 @@ public static void uint2x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -177,7 +177,7 @@ public static void uint2x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_less_wide_wide() { uint2x2 a0 = uint2x2(1486550609, 1779244308, 1602148045, 1614085440); @@ -201,7 +201,7 @@ public static void uint2x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_less_wide_scalar() { uint2x2 a0 = uint2x2(796797557, 670113454, 933579492, 278884514); @@ -225,7 +225,7 @@ public static void uint2x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -249,7 +249,7 @@ public static void uint2x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_greater_wide_wide() { uint2x2 a0 = uint2x2(2087717754, 1725569452, 1298066182, 1693943616); @@ -273,7 +273,7 @@ public static void uint2x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_greater_wide_scalar() { uint2x2 a0 = uint2x2(1208626274, 239697208, 1979453345, 1253474001); @@ -297,7 +297,7 @@ public static void uint2x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -321,7 +321,7 @@ public static void uint2x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_less_equal_wide_wide() { uint2x2 a0 = uint2x2(154092149, 1515170149, 1083970332, 785807178); @@ -345,7 +345,7 @@ public static void uint2x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_less_equal_wide_scalar() { uint2x2 a0 = uint2x2(1479531977, 1427983411, 415250630, 1245345407); @@ -369,7 +369,7 @@ public static void uint2x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -393,7 +393,7 @@ public static void uint2x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_greater_equal_wide_wide() { uint2x2 a0 = uint2x2(8538378, 2131749726, 265427108, 523609761); @@ -417,7 +417,7 @@ public static void uint2x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_greater_equal_wide_scalar() { uint2x2 a0 = uint2x2(2049236663, 182691143, 634973382, 1197012109); @@ -441,7 +441,7 @@ public static void uint2x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -465,7 +465,7 @@ public static void uint2x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_add_wide_wide() { uint2x2 a0 = uint2x2(2135171378, 21433296, 1954723494, 683604307); @@ -489,7 +489,7 @@ public static void uint2x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_add_wide_scalar() { uint2x2 a0 = uint2x2(665815972, 1783729250, 1591678394, 1284528538); @@ -513,7 +513,7 @@ public static void uint2x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -537,7 +537,7 @@ public static void uint2x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_sub_wide_wide() { uint2x2 a0 = uint2x2(1410318491, 1097280168, 1827039044, 28881338); @@ -561,7 +561,7 @@ public static void uint2x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_sub_wide_scalar() { uint2x2 a0 = uint2x2(1508669340, 1594795463, 266707545, 643102647); @@ -585,7 +585,7 @@ public static void uint2x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -609,7 +609,7 @@ public static void uint2x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_mul_wide_wide() { uint2x2 a0 = uint2x2(61417577, 219585476, 1362520891, 1511084277); @@ -633,7 +633,7 @@ public static void uint2x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_mul_wide_scalar() { uint2x2 a0 = uint2x2(871746615, 492532311, 570557670, 2142306629); @@ -657,7 +657,7 @@ public static void uint2x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -681,7 +681,7 @@ public static void uint2x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_div_wide_wide() { uint2x2 a0 = uint2x2(333171510, 858154903, 1181365836, 671357749); @@ -705,7 +705,7 @@ public static void uint2x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_div_wide_scalar() { uint2x2 a0 = uint2x2(1433072926, 1073958635, 1195142312, 536596719); @@ -729,7 +729,7 @@ public static void uint2x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -753,7 +753,7 @@ public static void uint2x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_mod_wide_wide() { uint2x2 a0 = uint2x2(258342924, 1454754891, 723352342, 1981431473); @@ -777,7 +777,7 @@ public static void uint2x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_mod_wide_scalar() { uint2x2 a0 = uint2x2(560988938, 629524514, 767711194, 434281967); @@ -801,7 +801,7 @@ public static void uint2x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -825,7 +825,7 @@ public static void uint2x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_plus() { uint2x2 a0 = uint2x2(195392567, 222719748, 1002351013, 1570765263); @@ -845,7 +845,7 @@ public static void uint2x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_neg() { uint2x2 a0 = uint2x2(1385088677, 94114564, 1350664872, 1458616659); @@ -865,7 +865,7 @@ public static void uint2x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_prefix_inc() { uint2x2 a0 = uint2x2(780471723, 954741756, 272723451, 2142862245); @@ -885,7 +885,7 @@ public static void uint2x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_postfix_inc() { uint2x2 a0 = uint2x2(241865086, 2145821641, 1596166022, 803592338); @@ -905,7 +905,7 @@ public static void uint2x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_prefix_dec() { uint2x2 a0 = uint2x2(1331961415, 1612382200, 1401591249, 2042075388); @@ -925,7 +925,7 @@ public static void uint2x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_postfix_dec() { uint2x2 a0 = uint2x2(1870005937, 1708534798, 704493460, 462940703); @@ -945,7 +945,7 @@ public static void uint2x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_and_wide_wide() { uint2x2 a0 = uint2x2(1055241304, 859321394, 1088358961, 2090949513); @@ -969,7 +969,7 @@ public static void uint2x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_and_wide_scalar() { uint2x2 a0 = uint2x2(1513158868, 284695609, 734595037, 1566510707); @@ -993,7 +993,7 @@ public static void uint2x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1017,7 +1017,7 @@ public static void uint2x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_or_wide_wide() { uint2x2 a0 = uint2x2(1920951869, 1750772852, 1420019191, 732977093); @@ -1041,7 +1041,7 @@ public static void uint2x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_or_wide_scalar() { uint2x2 a0 = uint2x2(1295304853, 1307252624, 350194630, 1128063578); @@ -1065,7 +1065,7 @@ public static void uint2x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1089,7 +1089,7 @@ public static void uint2x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_xor_wide_wide() { uint2x2 a0 = uint2x2(1843655608, 362425681, 640805534, 1342040268); @@ -1113,7 +1113,7 @@ public static void uint2x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_xor_wide_scalar() { uint2x2 a0 = uint2x2(169345668, 176087064, 2084362901, 1663924004); @@ -1137,7 +1137,7 @@ public static void uint2x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1161,7 +1161,7 @@ public static void uint2x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_left_shift() { uint2x2 a0 = uint2x2(1129100049, 829482269, 1571297368, 443753193); @@ -1185,7 +1185,7 @@ public static void uint2x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_right_shift() { uint2x2 a0 = uint2x2(809126085, 908563670, 763568837, 1986717290); @@ -1209,7 +1209,7 @@ public static void uint2x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x2_operator_bitwise_not() { uint2x2 a0 = uint2x2(111796841, 603562399, 745091931, 853183268); diff --git a/src/Tests/Tests/Shared/TestUint2x3.gen.cs b/src/Tests/Tests/Shared/TestUint2x3.gen.cs index 0dcca69a..ac053495 100644 --- a/src/Tests/Tests/Shared/TestUint2x3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_zero() { TestUtils.AreEqual(0u, uint2x3.zero.c0.x); @@ -26,7 +26,7 @@ public static void uint2x3_zero() TestUtils.AreEqual(0u, uint2x3.zero.c2.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_equal_wide_wide() { uint2x3 a0 = uint2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void uint2x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_equal_wide_scalar() { uint2x3 a0 = uint2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void uint2x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -98,7 +98,7 @@ public static void uint2x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_not_equal_wide_wide() { uint2x3 a0 = uint2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void uint2x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_not_equal_wide_scalar() { uint2x3 a0 = uint2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void uint2x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -170,7 +170,7 @@ public static void uint2x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_less_wide_wide() { uint2x3 a0 = uint2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void uint2x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_less_wide_scalar() { uint2x3 a0 = uint2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void uint2x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -242,7 +242,7 @@ public static void uint2x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_greater_wide_wide() { uint2x3 a0 = uint2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void uint2x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_greater_wide_scalar() { uint2x3 a0 = uint2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void uint2x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -314,7 +314,7 @@ public static void uint2x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_less_equal_wide_wide() { uint2x3 a0 = uint2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void uint2x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_less_equal_wide_scalar() { uint2x3 a0 = uint2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void uint2x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -386,7 +386,7 @@ public static void uint2x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_greater_equal_wide_wide() { uint2x3 a0 = uint2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void uint2x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_greater_equal_wide_scalar() { uint2x3 a0 = uint2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void uint2x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -458,7 +458,7 @@ public static void uint2x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_add_wide_wide() { uint2x3 a0 = uint2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void uint2x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_add_wide_scalar() { uint2x3 a0 = uint2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void uint2x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -530,7 +530,7 @@ public static void uint2x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_sub_wide_wide() { uint2x3 a0 = uint2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void uint2x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_sub_wide_scalar() { uint2x3 a0 = uint2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void uint2x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -602,7 +602,7 @@ public static void uint2x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_mul_wide_wide() { uint2x3 a0 = uint2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void uint2x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_mul_wide_scalar() { uint2x3 a0 = uint2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void uint2x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -674,7 +674,7 @@ public static void uint2x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_div_wide_wide() { uint2x3 a0 = uint2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void uint2x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_div_wide_scalar() { uint2x3 a0 = uint2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void uint2x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -746,7 +746,7 @@ public static void uint2x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_mod_wide_wide() { uint2x3 a0 = uint2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void uint2x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_mod_wide_scalar() { uint2x3 a0 = uint2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void uint2x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -818,7 +818,7 @@ public static void uint2x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_plus() { uint2x3 a0 = uint2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void uint2x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_neg() { uint2x3 a0 = uint2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void uint2x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_prefix_inc() { uint2x3 a0 = uint2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void uint2x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_postfix_inc() { uint2x3 a0 = uint2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void uint2x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_prefix_dec() { uint2x3 a0 = uint2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void uint2x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_postfix_dec() { uint2x3 a0 = uint2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void uint2x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_and_wide_wide() { uint2x3 a0 = uint2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void uint2x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_and_wide_scalar() { uint2x3 a0 = uint2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void uint2x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void uint2x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_or_wide_wide() { uint2x3 a0 = uint2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void uint2x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_or_wide_scalar() { uint2x3 a0 = uint2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void uint2x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void uint2x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_xor_wide_wide() { uint2x3 a0 = uint2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void uint2x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_xor_wide_scalar() { uint2x3 a0 = uint2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void uint2x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void uint2x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_left_shift() { uint2x3 a0 = uint2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void uint2x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_right_shift() { uint2x3 a0 = uint2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void uint2x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x3_operator_bitwise_not() { uint2x3 a0 = uint2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); diff --git a/src/Tests/Tests/Shared/TestUint2x4.gen.cs b/src/Tests/Tests/Shared/TestUint2x4.gen.cs index 645d9554..f9a8f210 100644 --- a/src/Tests/Tests/Shared/TestUint2x4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint2x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint2x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_zero() { TestUtils.AreEqual(0u, uint2x4.zero.c0.x); @@ -28,7 +28,7 @@ public static void uint2x4_zero() TestUtils.AreEqual(0u, uint2x4.zero.c3.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_equal_wide_wide() { uint2x4 a0 = uint2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void uint2x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_equal_wide_scalar() { uint2x4 a0 = uint2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void uint2x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -100,7 +100,7 @@ public static void uint2x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_not_equal_wide_wide() { uint2x4 a0 = uint2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void uint2x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_not_equal_wide_scalar() { uint2x4 a0 = uint2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void uint2x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -172,7 +172,7 @@ public static void uint2x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_less_wide_wide() { uint2x4 a0 = uint2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void uint2x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_less_wide_scalar() { uint2x4 a0 = uint2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void uint2x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -244,7 +244,7 @@ public static void uint2x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_greater_wide_wide() { uint2x4 a0 = uint2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void uint2x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_greater_wide_scalar() { uint2x4 a0 = uint2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void uint2x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -316,7 +316,7 @@ public static void uint2x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_less_equal_wide_wide() { uint2x4 a0 = uint2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void uint2x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_less_equal_wide_scalar() { uint2x4 a0 = uint2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void uint2x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -388,7 +388,7 @@ public static void uint2x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_greater_equal_wide_wide() { uint2x4 a0 = uint2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void uint2x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_greater_equal_wide_scalar() { uint2x4 a0 = uint2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void uint2x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -460,7 +460,7 @@ public static void uint2x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_add_wide_wide() { uint2x4 a0 = uint2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void uint2x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_add_wide_scalar() { uint2x4 a0 = uint2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void uint2x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -532,7 +532,7 @@ public static void uint2x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_sub_wide_wide() { uint2x4 a0 = uint2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void uint2x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_sub_wide_scalar() { uint2x4 a0 = uint2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void uint2x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -604,7 +604,7 @@ public static void uint2x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_mul_wide_wide() { uint2x4 a0 = uint2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void uint2x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_mul_wide_scalar() { uint2x4 a0 = uint2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void uint2x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -676,7 +676,7 @@ public static void uint2x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_div_wide_wide() { uint2x4 a0 = uint2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void uint2x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_div_wide_scalar() { uint2x4 a0 = uint2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void uint2x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -748,7 +748,7 @@ public static void uint2x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_mod_wide_wide() { uint2x4 a0 = uint2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void uint2x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_mod_wide_scalar() { uint2x4 a0 = uint2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void uint2x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -820,7 +820,7 @@ public static void uint2x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_plus() { uint2x4 a0 = uint2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void uint2x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_neg() { uint2x4 a0 = uint2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void uint2x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_prefix_inc() { uint2x4 a0 = uint2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void uint2x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_postfix_inc() { uint2x4 a0 = uint2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void uint2x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_prefix_dec() { uint2x4 a0 = uint2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void uint2x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_postfix_dec() { uint2x4 a0 = uint2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void uint2x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_and_wide_wide() { uint2x4 a0 = uint2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void uint2x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_and_wide_scalar() { uint2x4 a0 = uint2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void uint2x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void uint2x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_or_wide_wide() { uint2x4 a0 = uint2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void uint2x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_or_wide_scalar() { uint2x4 a0 = uint2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void uint2x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void uint2x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_xor_wide_wide() { uint2x4 a0 = uint2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void uint2x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_xor_wide_scalar() { uint2x4 a0 = uint2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void uint2x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void uint2x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_left_shift() { uint2x4 a0 = uint2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void uint2x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_right_shift() { uint2x4 a0 = uint2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void uint2x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2x4_operator_bitwise_not() { uint2x4 a0 = uint2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); diff --git a/src/Tests/Tests/Shared/TestUint3.gen.cs b/src/Tests/Tests/Shared/TestUint3.gen.cs index 67055e17..6443db9b 100644 --- a/src/Tests/Tests/Shared/TestUint3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_zero() { TestUtils.AreEqual(0u, uint3.zero.x); @@ -23,7 +23,7 @@ public static void uint3_zero() TestUtils.AreEqual(0u, uint3.zero.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_constructor() { uint3 a = new uint3(1, 2, 3); @@ -32,7 +32,7 @@ public static void uint3_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_scalar_constructor() { uint3 a = new uint3(17u); @@ -41,7 +41,7 @@ public static void uint3_scalar_constructor() TestUtils.AreEqual(17u, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_static_constructor() { uint3 a = uint3(1, 2, 3); @@ -50,7 +50,7 @@ public static void uint3_static_constructor() TestUtils.AreEqual(3, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_static_scalar_constructor() { uint3 a = uint3(17u); @@ -59,7 +59,7 @@ public static void uint3_static_scalar_constructor() TestUtils.AreEqual(17u, a.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_equal_wide_wide() { uint3 a0 = uint3(2105871082, 35218899, 1550755093); @@ -83,7 +83,7 @@ public static void uint3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_equal_wide_scalar() { uint3 a0 = uint3(437822262, 2020661134, 541786900); @@ -107,7 +107,7 @@ public static void uint3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -131,7 +131,7 @@ public static void uint3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_not_equal_wide_wide() { uint3 a0 = uint3(1977284100, 1293292704, 1547283851); @@ -155,7 +155,7 @@ public static void uint3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_not_equal_wide_scalar() { uint3 a0 = uint3(1038269360, 1427812625, 103361237); @@ -179,7 +179,7 @@ public static void uint3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -203,7 +203,7 @@ public static void uint3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_less_wide_wide() { uint3 a0 = uint3(1486550609, 1779244308, 1602148045); @@ -227,7 +227,7 @@ public static void uint3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_less_wide_scalar() { uint3 a0 = uint3(796797557, 670113454, 933579492); @@ -251,7 +251,7 @@ public static void uint3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -275,7 +275,7 @@ public static void uint3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_greater_wide_wide() { uint3 a0 = uint3(2087717754, 1725569452, 1298066182); @@ -299,7 +299,7 @@ public static void uint3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_greater_wide_scalar() { uint3 a0 = uint3(1208626274, 239697208, 1979453345); @@ -323,7 +323,7 @@ public static void uint3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -347,7 +347,7 @@ public static void uint3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_less_equal_wide_wide() { uint3 a0 = uint3(154092149, 1515170149, 1083970332); @@ -371,7 +371,7 @@ public static void uint3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_less_equal_wide_scalar() { uint3 a0 = uint3(1479531977, 1427983411, 415250630); @@ -395,7 +395,7 @@ public static void uint3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -419,7 +419,7 @@ public static void uint3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_greater_equal_wide_wide() { uint3 a0 = uint3(8538378, 2131749726, 265427108); @@ -443,7 +443,7 @@ public static void uint3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_greater_equal_wide_scalar() { uint3 a0 = uint3(2049236663, 182691143, 634973382); @@ -467,7 +467,7 @@ public static void uint3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -491,7 +491,7 @@ public static void uint3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_add_wide_wide() { uint3 a0 = uint3(2135171378, 21433296, 1954723494); @@ -515,7 +515,7 @@ public static void uint3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_add_wide_scalar() { uint3 a0 = uint3(665815972, 1783729250, 1591678394); @@ -539,7 +539,7 @@ public static void uint3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -563,7 +563,7 @@ public static void uint3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_sub_wide_wide() { uint3 a0 = uint3(1410318491, 1097280168, 1827039044); @@ -587,7 +587,7 @@ public static void uint3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_sub_wide_scalar() { uint3 a0 = uint3(1508669340, 1594795463, 266707545); @@ -611,7 +611,7 @@ public static void uint3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -635,7 +635,7 @@ public static void uint3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_mul_wide_wide() { uint3 a0 = uint3(61417577, 219585476, 1362520891); @@ -659,7 +659,7 @@ public static void uint3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_mul_wide_scalar() { uint3 a0 = uint3(871746615, 492532311, 570557670); @@ -683,7 +683,7 @@ public static void uint3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -707,7 +707,7 @@ public static void uint3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_div_wide_wide() { uint3 a0 = uint3(333171510, 858154903, 1181365836); @@ -731,7 +731,7 @@ public static void uint3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_div_wide_scalar() { uint3 a0 = uint3(1433072926, 1073958635, 1195142312); @@ -755,7 +755,7 @@ public static void uint3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -779,7 +779,7 @@ public static void uint3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_mod_wide_wide() { uint3 a0 = uint3(258342924, 1454754891, 723352342); @@ -803,7 +803,7 @@ public static void uint3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_mod_wide_scalar() { uint3 a0 = uint3(560988938, 629524514, 767711194); @@ -827,7 +827,7 @@ public static void uint3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -851,7 +851,7 @@ public static void uint3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_plus() { uint3 a0 = uint3(195392567, 222719748, 1002351013); @@ -871,7 +871,7 @@ public static void uint3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_neg() { uint3 a0 = uint3(1385088677, 94114564, 1350664872); @@ -891,7 +891,7 @@ public static void uint3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_prefix_inc() { uint3 a0 = uint3(780471723, 954741756, 272723451); @@ -911,7 +911,7 @@ public static void uint3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_postfix_inc() { uint3 a0 = uint3(241865086, 2145821641, 1596166022); @@ -931,7 +931,7 @@ public static void uint3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_prefix_dec() { uint3 a0 = uint3(1331961415, 1612382200, 1401591249); @@ -951,7 +951,7 @@ public static void uint3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_postfix_dec() { uint3 a0 = uint3(1870005937, 1708534798, 704493460); @@ -971,7 +971,7 @@ public static void uint3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_and_wide_wide() { uint3 a0 = uint3(1055241304, 859321394, 1088358961); @@ -995,7 +995,7 @@ public static void uint3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_and_wide_scalar() { uint3 a0 = uint3(1513158868, 284695609, 734595037); @@ -1019,7 +1019,7 @@ public static void uint3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1043,7 +1043,7 @@ public static void uint3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_or_wide_wide() { uint3 a0 = uint3(1920951869, 1750772852, 1420019191); @@ -1067,7 +1067,7 @@ public static void uint3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_or_wide_scalar() { uint3 a0 = uint3(1295304853, 1307252624, 350194630); @@ -1091,7 +1091,7 @@ public static void uint3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1115,7 +1115,7 @@ public static void uint3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_xor_wide_wide() { uint3 a0 = uint3(1843655608, 362425681, 640805534); @@ -1139,7 +1139,7 @@ public static void uint3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_xor_wide_scalar() { uint3 a0 = uint3(169345668, 176087064, 2084362901); @@ -1163,7 +1163,7 @@ public static void uint3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1187,7 +1187,7 @@ public static void uint3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_left_shift() { uint3 a0 = uint3(1129100049, 829482269, 1571297368); @@ -1211,7 +1211,7 @@ public static void uint3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_right_shift() { uint3 a0 = uint3(809126085, 908563670, 763568837); @@ -1235,7 +1235,7 @@ public static void uint3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_operator_bitwise_not() { uint3 a0 = uint3(111796841, 603562399, 745091931); @@ -1255,7 +1255,7 @@ public static void uint3_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_shuffle_result_1() { uint3 a = uint3(0, 1, 2); @@ -1269,7 +1269,7 @@ public static void uint3_shuffle_result_1() TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_shuffle_result_2() { uint3 a = uint3(0, 1, 2); @@ -1293,7 +1293,7 @@ public static void uint3_shuffle_result_2() TestUtils.AreEqual(uint2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_shuffle_result_3() { uint3 a = uint3(0, 1, 2); @@ -1317,7 +1317,7 @@ public static void uint3_shuffle_result_3() TestUtils.AreEqual(uint3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_shuffle_result_4() { uint3 a = uint3(0, 1, 2); diff --git a/src/Tests/Tests/Shared/TestUint3x2.gen.cs b/src/Tests/Tests/Shared/TestUint3x2.gen.cs index 71742df7..0072a061 100644 --- a/src/Tests/Tests/Shared/TestUint3x2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_zero() { TestUtils.AreEqual(0u, uint3x2.zero.c0.x); @@ -26,7 +26,7 @@ public static void uint3x2_zero() TestUtils.AreEqual(0u, uint3x2.zero.c1.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_equal_wide_wide() { uint3x2 a0 = uint3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098); @@ -50,7 +50,7 @@ public static void uint3x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_equal_wide_scalar() { uint3x2 a0 = uint3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405); @@ -74,7 +74,7 @@ public static void uint3x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -98,7 +98,7 @@ public static void uint3x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_not_equal_wide_wide() { uint3x2 a0 = uint3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892); @@ -122,7 +122,7 @@ public static void uint3x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_not_equal_wide_scalar() { uint3x2 a0 = uint3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802); @@ -146,7 +146,7 @@ public static void uint3x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -170,7 +170,7 @@ public static void uint3x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_less_wide_wide() { uint3x2 a0 = uint3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342); @@ -194,7 +194,7 @@ public static void uint3x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_less_wide_scalar() { uint3x2 a0 = uint3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673); @@ -218,7 +218,7 @@ public static void uint3x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -242,7 +242,7 @@ public static void uint3x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_greater_wide_wide() { uint3x2 a0 = uint3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491); @@ -266,7 +266,7 @@ public static void uint3x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_greater_wide_scalar() { uint3x2 a0 = uint3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635); @@ -290,7 +290,7 @@ public static void uint3x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -314,7 +314,7 @@ public static void uint3x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_less_equal_wide_wide() { uint3x2 a0 = uint3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627); @@ -338,7 +338,7 @@ public static void uint3x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_less_equal_wide_scalar() { uint3x2 a0 = uint3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632); @@ -362,7 +362,7 @@ public static void uint3x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -386,7 +386,7 @@ public static void uint3x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_greater_equal_wide_wide() { uint3x2 a0 = uint3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564); @@ -410,7 +410,7 @@ public static void uint3x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_greater_equal_wide_scalar() { uint3x2 a0 = uint3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469); @@ -434,7 +434,7 @@ public static void uint3x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -458,7 +458,7 @@ public static void uint3x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_add_wide_wide() { uint3x2 a0 = uint3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995); @@ -482,7 +482,7 @@ public static void uint3x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_add_wide_scalar() { uint3x2 a0 = uint3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732); @@ -506,7 +506,7 @@ public static void uint3x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -530,7 +530,7 @@ public static void uint3x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_sub_wide_wide() { uint3x2 a0 = uint3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868); @@ -554,7 +554,7 @@ public static void uint3x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_sub_wide_scalar() { uint3x2 a0 = uint3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328); @@ -578,7 +578,7 @@ public static void uint3x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -602,7 +602,7 @@ public static void uint3x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_mul_wide_wide() { uint3x2 a0 = uint3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871); @@ -626,7 +626,7 @@ public static void uint3x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_mul_wide_scalar() { uint3x2 a0 = uint3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563); @@ -650,7 +650,7 @@ public static void uint3x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -674,7 +674,7 @@ public static void uint3x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_div_wide_wide() { uint3x2 a0 = uint3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420); @@ -698,7 +698,7 @@ public static void uint3x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_div_wide_scalar() { uint3x2 a0 = uint3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346); @@ -722,7 +722,7 @@ public static void uint3x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -746,7 +746,7 @@ public static void uint3x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_mod_wide_wide() { uint3x2 a0 = uint3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627); @@ -770,7 +770,7 @@ public static void uint3x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_mod_wide_scalar() { uint3x2 a0 = uint3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846); @@ -794,7 +794,7 @@ public static void uint3x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -818,7 +818,7 @@ public static void uint3x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_plus() { uint3x2 a0 = uint3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277); @@ -838,7 +838,7 @@ public static void uint3x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_neg() { uint3x2 a0 = uint3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493); @@ -858,7 +858,7 @@ public static void uint3x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_prefix_inc() { uint3x2 a0 = uint3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550); @@ -878,7 +878,7 @@ public static void uint3x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_postfix_inc() { uint3x2 a0 = uint3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229); @@ -898,7 +898,7 @@ public static void uint3x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_prefix_dec() { uint3x2 a0 = uint3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159); @@ -918,7 +918,7 @@ public static void uint3x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_postfix_dec() { uint3x2 a0 = uint3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869); @@ -938,7 +938,7 @@ public static void uint3x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_and_wide_wide() { uint3x2 a0 = uint3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515); @@ -962,7 +962,7 @@ public static void uint3x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_and_wide_scalar() { uint3x2 a0 = uint3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838); @@ -986,7 +986,7 @@ public static void uint3x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1010,7 +1010,7 @@ public static void uint3x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_or_wide_wide() { uint3x2 a0 = uint3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930); @@ -1034,7 +1034,7 @@ public static void uint3x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_or_wide_scalar() { uint3x2 a0 = uint3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467); @@ -1058,7 +1058,7 @@ public static void uint3x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1082,7 +1082,7 @@ public static void uint3x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_xor_wide_wide() { uint3x2 a0 = uint3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850); @@ -1106,7 +1106,7 @@ public static void uint3x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_xor_wide_scalar() { uint3x2 a0 = uint3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661); @@ -1130,7 +1130,7 @@ public static void uint3x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1154,7 +1154,7 @@ public static void uint3x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_left_shift() { uint3x2 a0 = uint3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593); @@ -1178,7 +1178,7 @@ public static void uint3x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_right_shift() { uint3x2 a0 = uint3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842); @@ -1202,7 +1202,7 @@ public static void uint3x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x2_operator_bitwise_not() { uint3x2 a0 = uint3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399); diff --git a/src/Tests/Tests/Shared/TestUint3x3.gen.cs b/src/Tests/Tests/Shared/TestUint3x3.gen.cs index 6e679bba..9e91fc32 100644 --- a/src/Tests/Tests/Shared/TestUint3x3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_zero() { TestUtils.AreEqual(0u, uint3x3.zero.c0.x); @@ -29,7 +29,7 @@ public static void uint3x3_zero() TestUtils.AreEqual(0u, uint3x3.zero.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_identity() { TestUtils.AreEqual(1u, uint3x3.identity.c0.x); @@ -43,7 +43,7 @@ public static void uint3x3_identity() TestUtils.AreEqual(1u, uint3x3.identity.c2.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_equal_wide_wide() { uint3x3 a0 = uint3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367); @@ -67,7 +67,7 @@ public static void uint3x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_equal_wide_scalar() { uint3x3 a0 = uint3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998); @@ -91,7 +91,7 @@ public static void uint3x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -115,7 +115,7 @@ public static void uint3x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_not_equal_wide_wide() { uint3x3 a0 = uint3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678); @@ -139,7 +139,7 @@ public static void uint3x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_not_equal_wide_scalar() { uint3x3 a0 = uint3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423); @@ -163,7 +163,7 @@ public static void uint3x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -187,7 +187,7 @@ public static void uint3x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_less_wide_wide() { uint3x3 a0 = uint3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312); @@ -211,7 +211,7 @@ public static void uint3x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_less_wide_scalar() { uint3x3 a0 = uint3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597); @@ -235,7 +235,7 @@ public static void uint3x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -259,7 +259,7 @@ public static void uint3x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_greater_wide_wide() { uint3x3 a0 = uint3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133); @@ -283,7 +283,7 @@ public static void uint3x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_greater_wide_scalar() { uint3x3 a0 = uint3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855); @@ -307,7 +307,7 @@ public static void uint3x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -331,7 +331,7 @@ public static void uint3x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_less_equal_wide_wide() { uint3x3 a0 = uint3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541); @@ -355,7 +355,7 @@ public static void uint3x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_less_equal_wide_scalar() { uint3x3 a0 = uint3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375); @@ -379,7 +379,7 @@ public static void uint3x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -403,7 +403,7 @@ public static void uint3x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_greater_equal_wide_wide() { uint3x3 a0 = uint3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826); @@ -427,7 +427,7 @@ public static void uint3x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_greater_equal_wide_scalar() { uint3x3 a0 = uint3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669); @@ -451,7 +451,7 @@ public static void uint3x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -475,7 +475,7 @@ public static void uint3x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_add_wide_wide() { uint3x3 a0 = uint3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600); @@ -499,7 +499,7 @@ public static void uint3x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_add_wide_scalar() { uint3x3 a0 = uint3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008); @@ -523,7 +523,7 @@ public static void uint3x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -547,7 +547,7 @@ public static void uint3x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_sub_wide_wide() { uint3x3 a0 = uint3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315); @@ -571,7 +571,7 @@ public static void uint3x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_sub_wide_scalar() { uint3x3 a0 = uint3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113); @@ -595,7 +595,7 @@ public static void uint3x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -619,7 +619,7 @@ public static void uint3x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_mul_wide_wide() { uint3x3 a0 = uint3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583); @@ -643,7 +643,7 @@ public static void uint3x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_mul_wide_scalar() { uint3x3 a0 = uint3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059); @@ -667,7 +667,7 @@ public static void uint3x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -691,7 +691,7 @@ public static void uint3x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_div_wide_wide() { uint3x3 a0 = uint3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195); @@ -715,7 +715,7 @@ public static void uint3x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_div_wide_scalar() { uint3x3 a0 = uint3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136); @@ -739,7 +739,7 @@ public static void uint3x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -763,7 +763,7 @@ public static void uint3x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_mod_wide_wide() { uint3x3 a0 = uint3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101); @@ -787,7 +787,7 @@ public static void uint3x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_mod_wide_scalar() { uint3x3 a0 = uint3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144); @@ -811,7 +811,7 @@ public static void uint3x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -835,7 +835,7 @@ public static void uint3x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_plus() { uint3x3 a0 = uint3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671); @@ -855,7 +855,7 @@ public static void uint3x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_neg() { uint3x3 a0 = uint3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525); @@ -875,7 +875,7 @@ public static void uint3x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_prefix_inc() { uint3x3 a0 = uint3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994); @@ -895,7 +895,7 @@ public static void uint3x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_postfix_inc() { uint3x3 a0 = uint3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247); @@ -915,7 +915,7 @@ public static void uint3x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_prefix_dec() { uint3x3 a0 = uint3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745); @@ -935,7 +935,7 @@ public static void uint3x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_postfix_dec() { uint3x3 a0 = uint3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889); @@ -955,7 +955,7 @@ public static void uint3x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_and_wide_wide() { uint3x3 a0 = uint3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656); @@ -979,7 +979,7 @@ public static void uint3x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_and_wide_scalar() { uint3x3 a0 = uint3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263); @@ -1003,7 +1003,7 @@ public static void uint3x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1027,7 +1027,7 @@ public static void uint3x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_or_wide_wide() { uint3x3 a0 = uint3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869); @@ -1051,7 +1051,7 @@ public static void uint3x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_or_wide_scalar() { uint3x3 a0 = uint3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307); @@ -1075,7 +1075,7 @@ public static void uint3x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1099,7 +1099,7 @@ public static void uint3x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_xor_wide_wide() { uint3x3 a0 = uint3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251); @@ -1123,7 +1123,7 @@ public static void uint3x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_xor_wide_scalar() { uint3x3 a0 = uint3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873); @@ -1147,7 +1147,7 @@ public static void uint3x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1171,7 +1171,7 @@ public static void uint3x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_left_shift() { uint3x3 a0 = uint3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727); @@ -1195,7 +1195,7 @@ public static void uint3x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_right_shift() { uint3x3 a0 = uint3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393); @@ -1219,7 +1219,7 @@ public static void uint3x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x3_operator_bitwise_not() { uint3x3 a0 = uint3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628); diff --git a/src/Tests/Tests/Shared/TestUint3x4.gen.cs b/src/Tests/Tests/Shared/TestUint3x4.gen.cs index 00c414a7..4768c755 100644 --- a/src/Tests/Tests/Shared/TestUint3x4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint3x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint3x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_zero() { TestUtils.AreEqual(0u, uint3x4.zero.c0.x); @@ -32,7 +32,7 @@ public static void uint3x4_zero() TestUtils.AreEqual(0u, uint3x4.zero.c3.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_equal_wide_wide() { uint3x4 a0 = uint3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void uint3x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_equal_wide_scalar() { uint3x4 a0 = uint3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void uint3x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -104,7 +104,7 @@ public static void uint3x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_not_equal_wide_wide() { uint3x4 a0 = uint3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void uint3x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_not_equal_wide_scalar() { uint3x4 a0 = uint3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void uint3x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -176,7 +176,7 @@ public static void uint3x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_less_wide_wide() { uint3x4 a0 = uint3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void uint3x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_less_wide_scalar() { uint3x4 a0 = uint3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void uint3x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -248,7 +248,7 @@ public static void uint3x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_greater_wide_wide() { uint3x4 a0 = uint3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void uint3x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_greater_wide_scalar() { uint3x4 a0 = uint3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void uint3x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -320,7 +320,7 @@ public static void uint3x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_less_equal_wide_wide() { uint3x4 a0 = uint3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void uint3x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_less_equal_wide_scalar() { uint3x4 a0 = uint3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void uint3x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -392,7 +392,7 @@ public static void uint3x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_greater_equal_wide_wide() { uint3x4 a0 = uint3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void uint3x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_greater_equal_wide_scalar() { uint3x4 a0 = uint3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void uint3x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -464,7 +464,7 @@ public static void uint3x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_add_wide_wide() { uint3x4 a0 = uint3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void uint3x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_add_wide_scalar() { uint3x4 a0 = uint3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void uint3x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -536,7 +536,7 @@ public static void uint3x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_sub_wide_wide() { uint3x4 a0 = uint3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void uint3x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_sub_wide_scalar() { uint3x4 a0 = uint3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void uint3x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -608,7 +608,7 @@ public static void uint3x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_mul_wide_wide() { uint3x4 a0 = uint3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void uint3x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_mul_wide_scalar() { uint3x4 a0 = uint3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void uint3x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -680,7 +680,7 @@ public static void uint3x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_div_wide_wide() { uint3x4 a0 = uint3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void uint3x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_div_wide_scalar() { uint3x4 a0 = uint3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void uint3x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -752,7 +752,7 @@ public static void uint3x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_mod_wide_wide() { uint3x4 a0 = uint3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void uint3x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_mod_wide_scalar() { uint3x4 a0 = uint3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void uint3x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -824,7 +824,7 @@ public static void uint3x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_plus() { uint3x4 a0 = uint3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void uint3x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_neg() { uint3x4 a0 = uint3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void uint3x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_prefix_inc() { uint3x4 a0 = uint3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void uint3x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_postfix_inc() { uint3x4 a0 = uint3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void uint3x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_prefix_dec() { uint3x4 a0 = uint3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void uint3x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_postfix_dec() { uint3x4 a0 = uint3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void uint3x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_and_wide_wide() { uint3x4 a0 = uint3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void uint3x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_and_wide_scalar() { uint3x4 a0 = uint3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void uint3x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void uint3x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_or_wide_wide() { uint3x4 a0 = uint3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void uint3x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_or_wide_scalar() { uint3x4 a0 = uint3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void uint3x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void uint3x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_xor_wide_wide() { uint3x4 a0 = uint3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void uint3x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_xor_wide_scalar() { uint3x4 a0 = uint3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void uint3x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void uint3x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_left_shift() { uint3x4 a0 = uint3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void uint3x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_right_shift() { uint3x4 a0 = uint3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void uint3x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3x4_operator_bitwise_not() { uint3x4 a0 = uint3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); diff --git a/src/Tests/Tests/Shared/TestUint4.gen.cs b/src/Tests/Tests/Shared/TestUint4.gen.cs index 833012cd..8d0b8a6b 100644 --- a/src/Tests/Tests/Shared/TestUint4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_zero() { TestUtils.AreEqual(0u, uint4.zero.x); @@ -24,7 +24,7 @@ public static void uint4_zero() TestUtils.AreEqual(0u, uint4.zero.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_constructor() { uint4 a = new uint4(1, 2, 3, 4); @@ -34,7 +34,7 @@ public static void uint4_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_scalar_constructor() { uint4 a = new uint4(17u); @@ -44,7 +44,7 @@ public static void uint4_scalar_constructor() TestUtils.AreEqual(17u, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_static_constructor() { uint4 a = uint4(1, 2, 3, 4); @@ -54,7 +54,7 @@ public static void uint4_static_constructor() TestUtils.AreEqual(4, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_static_scalar_constructor() { uint4 a = uint4(17u); @@ -64,7 +64,7 @@ public static void uint4_static_scalar_constructor() TestUtils.AreEqual(17u, a.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_equal_wide_wide() { uint4 a0 = uint4(2105871082, 35218899, 1550755093, 764676020); @@ -88,7 +88,7 @@ public static void uint4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_equal_wide_scalar() { uint4 a0 = uint4(437822262, 2020661134, 541786900, 853113810); @@ -112,7 +112,7 @@ public static void uint4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -136,7 +136,7 @@ public static void uint4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_not_equal_wide_wide() { uint4 a0 = uint4(1977284100, 1293292704, 1547283851, 422428953); @@ -160,7 +160,7 @@ public static void uint4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_not_equal_wide_scalar() { uint4 a0 = uint4(1038269360, 1427812625, 103361237, 1347017023); @@ -184,7 +184,7 @@ public static void uint4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -208,7 +208,7 @@ public static void uint4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_less_wide_wide() { uint4 a0 = uint4(1486550609, 1779244308, 1602148045, 1614085440); @@ -232,7 +232,7 @@ public static void uint4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_less_wide_scalar() { uint4 a0 = uint4(796797557, 670113454, 933579492, 278884514); @@ -256,7 +256,7 @@ public static void uint4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -280,7 +280,7 @@ public static void uint4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_greater_wide_wide() { uint4 a0 = uint4(2087717754, 1725569452, 1298066182, 1693943616); @@ -304,7 +304,7 @@ public static void uint4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_greater_wide_scalar() { uint4 a0 = uint4(1208626274, 239697208, 1979453345, 1253474001); @@ -328,7 +328,7 @@ public static void uint4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -352,7 +352,7 @@ public static void uint4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_less_equal_wide_wide() { uint4 a0 = uint4(154092149, 1515170149, 1083970332, 785807178); @@ -376,7 +376,7 @@ public static void uint4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_less_equal_wide_scalar() { uint4 a0 = uint4(1479531977, 1427983411, 415250630, 1245345407); @@ -400,7 +400,7 @@ public static void uint4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -424,7 +424,7 @@ public static void uint4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_greater_equal_wide_wide() { uint4 a0 = uint4(8538378, 2131749726, 265427108, 523609761); @@ -448,7 +448,7 @@ public static void uint4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_greater_equal_wide_scalar() { uint4 a0 = uint4(2049236663, 182691143, 634973382, 1197012109); @@ -472,7 +472,7 @@ public static void uint4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -496,7 +496,7 @@ public static void uint4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_add_wide_wide() { uint4 a0 = uint4(2135171378, 21433296, 1954723494, 683604307); @@ -520,7 +520,7 @@ public static void uint4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_add_wide_scalar() { uint4 a0 = uint4(665815972, 1783729250, 1591678394, 1284528538); @@ -544,7 +544,7 @@ public static void uint4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -568,7 +568,7 @@ public static void uint4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_sub_wide_wide() { uint4 a0 = uint4(1410318491, 1097280168, 1827039044, 28881338); @@ -592,7 +592,7 @@ public static void uint4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_sub_wide_scalar() { uint4 a0 = uint4(1508669340, 1594795463, 266707545, 643102647); @@ -616,7 +616,7 @@ public static void uint4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -640,7 +640,7 @@ public static void uint4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_mul_wide_wide() { uint4 a0 = uint4(61417577, 219585476, 1362520891, 1511084277); @@ -664,7 +664,7 @@ public static void uint4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_mul_wide_scalar() { uint4 a0 = uint4(871746615, 492532311, 570557670, 2142306629); @@ -688,7 +688,7 @@ public static void uint4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -712,7 +712,7 @@ public static void uint4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_div_wide_wide() { uint4 a0 = uint4(333171510, 858154903, 1181365836, 671357749); @@ -736,7 +736,7 @@ public static void uint4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_div_wide_scalar() { uint4 a0 = uint4(1433072926, 1073958635, 1195142312, 536596719); @@ -760,7 +760,7 @@ public static void uint4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -784,7 +784,7 @@ public static void uint4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_mod_wide_wide() { uint4 a0 = uint4(258342924, 1454754891, 723352342, 1981431473); @@ -808,7 +808,7 @@ public static void uint4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_mod_wide_scalar() { uint4 a0 = uint4(560988938, 629524514, 767711194, 434281967); @@ -832,7 +832,7 @@ public static void uint4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -856,7 +856,7 @@ public static void uint4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_plus() { uint4 a0 = uint4(195392567, 222719748, 1002351013, 1570765263); @@ -876,7 +876,7 @@ public static void uint4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_neg() { uint4 a0 = uint4(1385088677, 94114564, 1350664872, 1458616659); @@ -896,7 +896,7 @@ public static void uint4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_prefix_inc() { uint4 a0 = uint4(780471723, 954741756, 272723451, 2142862245); @@ -916,7 +916,7 @@ public static void uint4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_postfix_inc() { uint4 a0 = uint4(241865086, 2145821641, 1596166022, 803592338); @@ -936,7 +936,7 @@ public static void uint4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_prefix_dec() { uint4 a0 = uint4(1331961415, 1612382200, 1401591249, 2042075388); @@ -956,7 +956,7 @@ public static void uint4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_postfix_dec() { uint4 a0 = uint4(1870005937, 1708534798, 704493460, 462940703); @@ -976,7 +976,7 @@ public static void uint4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_and_wide_wide() { uint4 a0 = uint4(1055241304, 859321394, 1088358961, 2090949513); @@ -1000,7 +1000,7 @@ public static void uint4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_and_wide_scalar() { uint4 a0 = uint4(1513158868, 284695609, 734595037, 1566510707); @@ -1024,7 +1024,7 @@ public static void uint4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1048,7 +1048,7 @@ public static void uint4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_or_wide_wide() { uint4 a0 = uint4(1920951869, 1750772852, 1420019191, 732977093); @@ -1072,7 +1072,7 @@ public static void uint4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_or_wide_scalar() { uint4 a0 = uint4(1295304853, 1307252624, 350194630, 1128063578); @@ -1096,7 +1096,7 @@ public static void uint4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1120,7 +1120,7 @@ public static void uint4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_xor_wide_wide() { uint4 a0 = uint4(1843655608, 362425681, 640805534, 1342040268); @@ -1144,7 +1144,7 @@ public static void uint4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_xor_wide_scalar() { uint4 a0 = uint4(169345668, 176087064, 2084362901, 1663924004); @@ -1168,7 +1168,7 @@ public static void uint4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1192,7 +1192,7 @@ public static void uint4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_left_shift() { uint4 a0 = uint4(1129100049, 829482269, 1571297368, 443753193); @@ -1216,7 +1216,7 @@ public static void uint4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_right_shift() { uint4 a0 = uint4(809126085, 908563670, 763568837, 1986717290); @@ -1240,7 +1240,7 @@ public static void uint4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_operator_bitwise_not() { uint4 a0 = uint4(111796841, 603562399, 745091931, 853183268); @@ -1260,7 +1260,7 @@ public static void uint4_operator_bitwise_not() TestUtils.AreEqual(r3, ~a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_shuffle_result_1() { uint4 a = uint4(0, 1, 2, 3); @@ -1276,7 +1276,7 @@ public static void uint4_shuffle_result_1() TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_shuffle_result_2() { uint4 a = uint4(0, 1, 2, 3); @@ -1300,7 +1300,7 @@ public static void uint4_shuffle_result_2() TestUtils.AreEqual(uint2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_shuffle_result_3() { uint4 a = uint4(0, 1, 2, 3); @@ -1324,7 +1324,7 @@ public static void uint4_shuffle_result_3() TestUtils.AreEqual(uint3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_shuffle_result_4() { uint4 a = uint4(0, 1, 2, 3); diff --git a/src/Tests/Tests/Shared/TestUint4x2.gen.cs b/src/Tests/Tests/Shared/TestUint4x2.gen.cs index 9d2bba1f..7f42bc6a 100644 --- a/src/Tests/Tests/Shared/TestUint4x2.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4x2.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4x2 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_zero() { TestUtils.AreEqual(0u, uint4x2.zero.c0.x); @@ -28,7 +28,7 @@ public static void uint4x2_zero() TestUtils.AreEqual(0u, uint4x2.zero.c1.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_equal_wide_wide() { uint4x2 a0 = uint4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316); @@ -52,7 +52,7 @@ public static void uint4x2_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_equal_wide_scalar() { uint4x2 a0 = uint4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849); @@ -76,7 +76,7 @@ public static void uint4x2_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -100,7 +100,7 @@ public static void uint4x2_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_not_equal_wide_wide() { uint4x2 a0 = uint4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074); @@ -124,7 +124,7 @@ public static void uint4x2_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_not_equal_wide_scalar() { uint4x2 a0 = uint4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717); @@ -148,7 +148,7 @@ public static void uint4x2_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -172,7 +172,7 @@ public static void uint4x2_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_less_wide_wide() { uint4x2 a0 = uint4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431); @@ -196,7 +196,7 @@ public static void uint4x2_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_less_wide_scalar() { uint4x2 a0 = uint4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600); @@ -220,7 +220,7 @@ public static void uint4x2_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_less_scalar_wide() { uint a0 = (186400299); @@ -244,7 +244,7 @@ public static void uint4x2_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_greater_wide_wide() { uint4x2 a0 = uint4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508); @@ -268,7 +268,7 @@ public static void uint4x2_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_greater_wide_scalar() { uint4x2 a0 = uint4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098); @@ -292,7 +292,7 @@ public static void uint4x2_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -316,7 +316,7 @@ public static void uint4x2_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_less_equal_wide_wide() { uint4x2 a0 = uint4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725); @@ -340,7 +340,7 @@ public static void uint4x2_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_less_equal_wide_scalar() { uint4x2 a0 = uint4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307); @@ -364,7 +364,7 @@ public static void uint4x2_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -388,7 +388,7 @@ public static void uint4x2_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_greater_equal_wide_wide() { uint4x2 a0 = uint4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970); @@ -412,7 +412,7 @@ public static void uint4x2_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_greater_equal_wide_scalar() { uint4x2 a0 = uint4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187); @@ -436,7 +436,7 @@ public static void uint4x2_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -460,7 +460,7 @@ public static void uint4x2_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_add_wide_wide() { uint4x2 a0 = uint4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062); @@ -484,7 +484,7 @@ public static void uint4x2_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_add_wide_scalar() { uint4x2 a0 = uint4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017); @@ -508,7 +508,7 @@ public static void uint4x2_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_add_scalar_wide() { uint a0 = (359966320); @@ -532,7 +532,7 @@ public static void uint4x2_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_sub_wide_wide() { uint4x2 a0 = uint4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215); @@ -556,7 +556,7 @@ public static void uint4x2_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_sub_wide_scalar() { uint4x2 a0 = uint4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511); @@ -580,7 +580,7 @@ public static void uint4x2_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -604,7 +604,7 @@ public static void uint4x2_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_mul_wide_wide() { uint4x2 a0 = uint4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644); @@ -628,7 +628,7 @@ public static void uint4x2_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_mul_wide_scalar() { uint4x2 a0 = uint4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514); @@ -652,7 +652,7 @@ public static void uint4x2_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -676,7 +676,7 @@ public static void uint4x2_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_div_wide_wide() { uint4x2 a0 = uint4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814); @@ -700,7 +700,7 @@ public static void uint4x2_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_div_wide_scalar() { uint4x2 a0 = uint4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670); @@ -724,7 +724,7 @@ public static void uint4x2_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_div_scalar_wide() { uint a0 = (519165704); @@ -748,7 +748,7 @@ public static void uint4x2_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_mod_wide_wide() { uint4x2 a0 = uint4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004); @@ -772,7 +772,7 @@ public static void uint4x2_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_mod_wide_scalar() { uint4x2 a0 = uint4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916); @@ -796,7 +796,7 @@ public static void uint4x2_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -820,7 +820,7 @@ public static void uint4x2_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_plus() { uint4x2 a0 = uint4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785); @@ -840,7 +840,7 @@ public static void uint4x2_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_neg() { uint4x2 a0 = uint4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961); @@ -860,7 +860,7 @@ public static void uint4x2_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_prefix_inc() { uint4x2 a0 = uint4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162); @@ -880,7 +880,7 @@ public static void uint4x2_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_postfix_inc() { uint4x2 a0 = uint4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244); @@ -900,7 +900,7 @@ public static void uint4x2_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_prefix_dec() { uint4x2 a0 = uint4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664); @@ -920,7 +920,7 @@ public static void uint4x2_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_postfix_dec() { uint4x2 a0 = uint4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351); @@ -940,7 +940,7 @@ public static void uint4x2_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_and_wide_wide() { uint4x2 a0 = uint4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753); @@ -964,7 +964,7 @@ public static void uint4x2_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_and_wide_scalar() { uint4x2 a0 = uint4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908); @@ -988,7 +988,7 @@ public static void uint4x2_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1012,7 +1012,7 @@ public static void uint4x2_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_or_wide_wide() { uint4x2 a0 = uint4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323); @@ -1036,7 +1036,7 @@ public static void uint4x2_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_or_wide_scalar() { uint4x2 a0 = uint4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350); @@ -1060,7 +1060,7 @@ public static void uint4x2_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1084,7 +1084,7 @@ public static void uint4x2_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_xor_wide_wide() { uint4x2 a0 = uint4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658); @@ -1108,7 +1108,7 @@ public static void uint4x2_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_xor_wide_scalar() { uint4x2 a0 = uint4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783); @@ -1132,7 +1132,7 @@ public static void uint4x2_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1156,7 +1156,7 @@ public static void uint4x2_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_left_shift() { uint4x2 a0 = uint4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862); @@ -1180,7 +1180,7 @@ public static void uint4x2_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_right_shift() { uint4x2 a0 = uint4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632); @@ -1204,7 +1204,7 @@ public static void uint4x2_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x2_operator_bitwise_not() { uint4x2 a0 = uint4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135); diff --git a/src/Tests/Tests/Shared/TestUint4x3.gen.cs b/src/Tests/Tests/Shared/TestUint4x3.gen.cs index bc2aba8a..f750426b 100644 --- a/src/Tests/Tests/Shared/TestUint4x3.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4x3.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4x3 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_zero() { TestUtils.AreEqual(0u, uint4x3.zero.c0.x); @@ -32,7 +32,7 @@ public static void uint4x3_zero() TestUtils.AreEqual(0u, uint4x3.zero.c2.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_equal_wide_wide() { uint4x3 a0 = uint4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837); @@ -56,7 +56,7 @@ public static void uint4x3_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_equal_wide_scalar() { uint4x3 a0 = uint4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137); @@ -80,7 +80,7 @@ public static void uint4x3_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -104,7 +104,7 @@ public static void uint4x3_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_not_equal_wide_wide() { uint4x3 a0 = uint4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545); @@ -128,7 +128,7 @@ public static void uint4x3_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_not_equal_wide_scalar() { uint4x3 a0 = uint4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494); @@ -152,7 +152,7 @@ public static void uint4x3_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -176,7 +176,7 @@ public static void uint4x3_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_less_wide_wide() { uint4x3 a0 = uint4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069); @@ -200,7 +200,7 @@ public static void uint4x3_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_less_wide_scalar() { uint4x3 a0 = uint4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417); @@ -224,7 +224,7 @@ public static void uint4x3_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_less_scalar_wide() { uint a0 = (186400299); @@ -248,7 +248,7 @@ public static void uint4x3_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_greater_wide_wide() { uint4x3 a0 = uint4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903); @@ -272,7 +272,7 @@ public static void uint4x3_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_greater_wide_scalar() { uint4x3 a0 = uint4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960); @@ -296,7 +296,7 @@ public static void uint4x3_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -320,7 +320,7 @@ public static void uint4x3_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_less_equal_wide_wide() { uint4x3 a0 = uint4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946); @@ -344,7 +344,7 @@ public static void uint4x3_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_less_equal_wide_scalar() { uint4x3 a0 = uint4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501); @@ -368,7 +368,7 @@ public static void uint4x3_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -392,7 +392,7 @@ public static void uint4x3_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_greater_equal_wide_wide() { uint4x3 a0 = uint4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752); @@ -416,7 +416,7 @@ public static void uint4x3_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_greater_equal_wide_scalar() { uint4x3 a0 = uint4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390); @@ -440,7 +440,7 @@ public static void uint4x3_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -464,7 +464,7 @@ public static void uint4x3_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_add_wide_wide() { uint4x3 a0 = uint4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462); @@ -488,7 +488,7 @@ public static void uint4x3_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_add_wide_scalar() { uint4x3 a0 = uint4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642); @@ -512,7 +512,7 @@ public static void uint4x3_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_add_scalar_wide() { uint a0 = (359966320); @@ -536,7 +536,7 @@ public static void uint4x3_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_sub_wide_wide() { uint4x3 a0 = uint4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285); @@ -560,7 +560,7 @@ public static void uint4x3_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_sub_wide_scalar() { uint4x3 a0 = uint4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508); @@ -584,7 +584,7 @@ public static void uint4x3_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -608,7 +608,7 @@ public static void uint4x3_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_mul_wide_wide() { uint4x3 a0 = uint4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842); @@ -632,7 +632,7 @@ public static void uint4x3_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_mul_wide_scalar() { uint4x3 a0 = uint4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203); @@ -656,7 +656,7 @@ public static void uint4x3_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -680,7 +680,7 @@ public static void uint4x3_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_div_wide_wide() { uint4x3 a0 = uint4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736); @@ -704,7 +704,7 @@ public static void uint4x3_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_div_wide_scalar() { uint4x3 a0 = uint4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377); @@ -728,7 +728,7 @@ public static void uint4x3_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_div_scalar_wide() { uint a0 = (519165704); @@ -752,7 +752,7 @@ public static void uint4x3_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_mod_wide_wide() { uint4x3 a0 = uint4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293); @@ -776,7 +776,7 @@ public static void uint4x3_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_mod_wide_scalar() { uint4x3 a0 = uint4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785); @@ -800,7 +800,7 @@ public static void uint4x3_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -824,7 +824,7 @@ public static void uint4x3_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_plus() { uint4x3 a0 = uint4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223); @@ -844,7 +844,7 @@ public static void uint4x3_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_neg() { uint4x3 a0 = uint4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822); @@ -864,7 +864,7 @@ public static void uint4x3_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_prefix_inc() { uint4x3 a0 = uint4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735); @@ -884,7 +884,7 @@ public static void uint4x3_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_postfix_inc() { uint4x3 a0 = uint4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446); @@ -904,7 +904,7 @@ public static void uint4x3_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_prefix_dec() { uint4x3 a0 = uint4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220); @@ -924,7 +924,7 @@ public static void uint4x3_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_postfix_dec() { uint4x3 a0 = uint4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851); @@ -944,7 +944,7 @@ public static void uint4x3_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_and_wide_wide() { uint4x3 a0 = uint4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302); @@ -968,7 +968,7 @@ public static void uint4x3_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_and_wide_scalar() { uint4x3 a0 = uint4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546); @@ -992,7 +992,7 @@ public static void uint4x3_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1016,7 +1016,7 @@ public static void uint4x3_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_or_wide_wide() { uint4x3 a0 = uint4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227); @@ -1040,7 +1040,7 @@ public static void uint4x3_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_or_wide_scalar() { uint4x3 a0 = uint4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676); @@ -1064,7 +1064,7 @@ public static void uint4x3_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1088,7 +1088,7 @@ public static void uint4x3_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_xor_wide_wide() { uint4x3 a0 = uint4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919); @@ -1112,7 +1112,7 @@ public static void uint4x3_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_xor_wide_scalar() { uint4x3 a0 = uint4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786); @@ -1136,7 +1136,7 @@ public static void uint4x3_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1160,7 +1160,7 @@ public static void uint4x3_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_left_shift() { uint4x3 a0 = uint4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902); @@ -1184,7 +1184,7 @@ public static void uint4x3_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_right_shift() { uint4x3 a0 = uint4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878); @@ -1208,7 +1208,7 @@ public static void uint4x3_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x3_operator_bitwise_not() { uint4x3 a0 = uint4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785); diff --git a/src/Tests/Tests/Shared/TestUint4x4.gen.cs b/src/Tests/Tests/Shared/TestUint4x4.gen.cs index 03234c47..b9fc3f5e 100644 --- a/src/Tests/Tests/Shared/TestUint4x4.gen.cs +++ b/src/Tests/Tests/Shared/TestUint4x4.gen.cs @@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public class TestUint4x4 { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_zero() { TestUtils.AreEqual(0u, uint4x4.zero.c0.x); @@ -36,7 +36,7 @@ public static void uint4x4_zero() TestUtils.AreEqual(0u, uint4x4.zero.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_identity() { TestUtils.AreEqual(1u, uint4x4.identity.c0.x); @@ -57,7 +57,7 @@ public static void uint4x4_identity() TestUtils.AreEqual(1u, uint4x4.identity.c3.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_equal_wide_wide() { uint4x4 a0 = uint4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805); @@ -81,7 +81,7 @@ public static void uint4x4_operator_equal_wide_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_equal_wide_scalar() { uint4x4 a0 = uint4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611); @@ -105,7 +105,7 @@ public static void uint4x4_operator_equal_wide_scalar() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_equal_scalar_wide() { uint a0 = (542329200); @@ -129,7 +129,7 @@ public static void uint4x4_operator_equal_scalar_wide() TestUtils.AreEqual(r3, a3 == b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_not_equal_wide_wide() { uint4x4 a0 = uint4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126); @@ -153,7 +153,7 @@ public static void uint4x4_operator_not_equal_wide_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_not_equal_wide_scalar() { uint4x4 a0 = uint4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260); @@ -177,7 +177,7 @@ public static void uint4x4_operator_not_equal_wide_scalar() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_not_equal_scalar_wide() { uint a0 = (1652127596); @@ -201,7 +201,7 @@ public static void uint4x4_operator_not_equal_scalar_wide() TestUtils.AreEqual(r3, a3 != b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_less_wide_wide() { uint4x4 a0 = uint4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012); @@ -225,7 +225,7 @@ public static void uint4x4_operator_less_wide_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_less_wide_scalar() { uint4x4 a0 = uint4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157); @@ -249,7 +249,7 @@ public static void uint4x4_operator_less_wide_scalar() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_less_scalar_wide() { uint a0 = (186400299); @@ -273,7 +273,7 @@ public static void uint4x4_operator_less_scalar_wide() TestUtils.AreEqual(r3, a3 < b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_greater_wide_wide() { uint4x4 a0 = uint4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063); @@ -297,7 +297,7 @@ public static void uint4x4_operator_greater_wide_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_greater_wide_scalar() { uint4x4 a0 = uint4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537); @@ -321,7 +321,7 @@ public static void uint4x4_operator_greater_wide_scalar() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_greater_scalar_wide() { uint a0 = (480938827); @@ -345,7 +345,7 @@ public static void uint4x4_operator_greater_scalar_wide() TestUtils.AreEqual(r3, a3 > b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_less_equal_wide_wide() { uint4x4 a0 = uint4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458); @@ -369,7 +369,7 @@ public static void uint4x4_operator_less_equal_wide_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_less_equal_wide_scalar() { uint4x4 a0 = uint4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699); @@ -393,7 +393,7 @@ public static void uint4x4_operator_less_equal_wide_scalar() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_less_equal_scalar_wide() { uint a0 = (1899193992); @@ -417,7 +417,7 @@ public static void uint4x4_operator_less_equal_scalar_wide() TestUtils.AreEqual(r3, a3 <= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_greater_equal_wide_wide() { uint4x4 a0 = uint4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690); @@ -441,7 +441,7 @@ public static void uint4x4_operator_greater_equal_wide_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_greater_equal_wide_scalar() { uint4x4 a0 = uint4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144); @@ -465,7 +465,7 @@ public static void uint4x4_operator_greater_equal_wide_scalar() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_greater_equal_scalar_wide() { uint a0 = (1859811087); @@ -489,7 +489,7 @@ public static void uint4x4_operator_greater_equal_scalar_wide() TestUtils.AreEqual(r3, a3 >= b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_add_wide_wide() { uint4x4 a0 = uint4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699); @@ -513,7 +513,7 @@ public static void uint4x4_operator_add_wide_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_add_wide_scalar() { uint4x4 a0 = uint4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741); @@ -537,7 +537,7 @@ public static void uint4x4_operator_add_wide_scalar() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_add_scalar_wide() { uint a0 = (359966320); @@ -561,7 +561,7 @@ public static void uint4x4_operator_add_scalar_wide() TestUtils.AreEqual(r3, a3 + b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_sub_wide_wide() { uint4x4 a0 = uint4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464); @@ -585,7 +585,7 @@ public static void uint4x4_operator_sub_wide_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_sub_wide_scalar() { uint4x4 a0 = uint4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902); @@ -609,7 +609,7 @@ public static void uint4x4_operator_sub_wide_scalar() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_sub_scalar_wide() { uint a0 = (893369501); @@ -633,7 +633,7 @@ public static void uint4x4_operator_sub_scalar_wide() TestUtils.AreEqual(r3, a3 - b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_mul_wide_wide() { uint4x4 a0 = uint4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174); @@ -657,7 +657,7 @@ public static void uint4x4_operator_mul_wide_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_mul_wide_scalar() { uint4x4 a0 = uint4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135); @@ -681,7 +681,7 @@ public static void uint4x4_operator_mul_wide_scalar() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_mul_scalar_wide() { uint a0 = (1152242766); @@ -705,7 +705,7 @@ public static void uint4x4_operator_mul_scalar_wide() TestUtils.AreEqual(r3, a3 * b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_div_wide_wide() { uint4x4 a0 = uint4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781); @@ -729,7 +729,7 @@ public static void uint4x4_operator_div_wide_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_div_wide_scalar() { uint4x4 a0 = uint4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263); @@ -753,7 +753,7 @@ public static void uint4x4_operator_div_wide_scalar() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_div_scalar_wide() { uint a0 = (519165704); @@ -777,7 +777,7 @@ public static void uint4x4_operator_div_scalar_wide() TestUtils.AreEqual(r3, a3 / b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_mod_wide_wide() { uint4x4 a0 = uint4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943); @@ -801,7 +801,7 @@ public static void uint4x4_operator_mod_wide_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_mod_wide_scalar() { uint4x4 a0 = uint4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114); @@ -825,7 +825,7 @@ public static void uint4x4_operator_mod_wide_scalar() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_mod_scalar_wide() { uint a0 = (933347930); @@ -849,7 +849,7 @@ public static void uint4x4_operator_mod_scalar_wide() TestUtils.AreEqual(r3, a3 % b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_plus() { uint4x4 a0 = uint4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903); @@ -869,7 +869,7 @@ public static void uint4x4_operator_plus() TestUtils.AreEqual(r3, +a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_neg() { uint4x4 a0 = uint4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416); @@ -889,7 +889,7 @@ public static void uint4x4_operator_neg() TestUtils.AreEqual(r3, -a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_prefix_inc() { uint4x4 a0 = uint4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230); @@ -909,7 +909,7 @@ public static void uint4x4_operator_prefix_inc() TestUtils.AreEqual(r3, ++a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_postfix_inc() { uint4x4 a0 = uint4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180); @@ -929,7 +929,7 @@ public static void uint4x4_operator_postfix_inc() TestUtils.AreEqual(r3, a3++); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_prefix_dec() { uint4x4 a0 = uint4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619); @@ -949,7 +949,7 @@ public static void uint4x4_operator_prefix_dec() TestUtils.AreEqual(r3, --a3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_postfix_dec() { uint4x4 a0 = uint4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301); @@ -969,7 +969,7 @@ public static void uint4x4_operator_postfix_dec() TestUtils.AreEqual(r3, a3--); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_and_wide_wide() { uint4x4 a0 = uint4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376); @@ -993,7 +993,7 @@ public static void uint4x4_operator_bitwise_and_wide_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_and_wide_scalar() { uint4x4 a0 = uint4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952); @@ -1017,7 +1017,7 @@ public static void uint4x4_operator_bitwise_and_wide_scalar() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_and_scalar_wide() { uint a0 = (477163326); @@ -1041,7 +1041,7 @@ public static void uint4x4_operator_bitwise_and_scalar_wide() TestUtils.AreEqual(r3, a3 & b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_or_wide_wide() { uint4x4 a0 = uint4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729); @@ -1065,7 +1065,7 @@ public static void uint4x4_operator_bitwise_or_wide_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_or_wide_scalar() { uint4x4 a0 = uint4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773); @@ -1089,7 +1089,7 @@ public static void uint4x4_operator_bitwise_or_wide_scalar() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_or_scalar_wide() { uint a0 = (1768627592); @@ -1113,7 +1113,7 @@ public static void uint4x4_operator_bitwise_or_scalar_wide() TestUtils.AreEqual(r3, a3 | b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_xor_wide_wide() { uint4x4 a0 = uint4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576); @@ -1137,7 +1137,7 @@ public static void uint4x4_operator_bitwise_xor_wide_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_xor_wide_scalar() { uint4x4 a0 = uint4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598); @@ -1161,7 +1161,7 @@ public static void uint4x4_operator_bitwise_xor_wide_scalar() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_xor_scalar_wide() { uint a0 = (1361775641); @@ -1185,7 +1185,7 @@ public static void uint4x4_operator_bitwise_xor_scalar_wide() TestUtils.AreEqual(r3, a3 ^ b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_left_shift() { uint4x4 a0 = uint4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915); @@ -1209,7 +1209,7 @@ public static void uint4x4_operator_left_shift() TestUtils.AreEqual(r3, a3 << b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_right_shift() { uint4x4 a0 = uint4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287); @@ -1233,7 +1233,7 @@ public static void uint4x4_operator_right_shift() TestUtils.AreEqual(r3, a3 >> b3); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4x4_operator_bitwise_not() { uint4x4 a0 = uint4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736); diff --git a/src/Tests/Tests/TestMath2.cs b/src/Tests/Tests/TestMath2.cs index 7bbac675..02b48ddb 100644 --- a/src/Tests/Tests/TestMath2.cs +++ b/src/Tests/Tests/TestMath2.cs @@ -8,7 +8,7 @@ namespace Unity.Mathematics.Tests [TestFixture] public partial class TestMath { - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public unsafe void hash_blob() { byte[] testData = { @@ -61,7 +61,7 @@ public unsafe void hash_blob() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public unsafe void hash_blob_unaligned() { byte[] testData = { diff --git a/src/Tests/Tests/TestRandom.cs b/src/Tests/Tests/TestRandom.cs index 9de2112b..35bc9abd 100644 --- a/src/Tests/Tests/TestRandom.cs +++ b/src/Tests/Tests/TestRandom.cs @@ -115,14 +115,14 @@ private static double range_check(double x, double min, double max) } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool_uniform() { var rnd = new Random(0x6E624EB7u); ks_test((() => rnd.NextBool() ? 0.75 : 0.25), 2); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_uniform() { var rnd = new Random(0x6E624EB7u); @@ -130,14 +130,14 @@ public static void bool2_uniform() ks_test((() => rnd.NextBool2().y ? 0.75 : 0.25), 2); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool2_independent() { var rnd = new Random(0x6E624EB7u); r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool2().xy))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_uniform() { var rnd = new Random(0x6E624EB7u); @@ -146,7 +146,7 @@ public static void bool3_uniform() ks_test((() => rnd.NextBool3().z ? 0.75 : 0.25), 2); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool3_independent() { var rnd = new Random(0x6E624EB7u); @@ -155,7 +155,7 @@ public static void bool3_independent() r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().yz))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_uniform() { var rnd = new Random(0x6E624EB7u); @@ -165,7 +165,7 @@ public static void bool4_uniform() ks_test((() => rnd.NextBool4().w ? 0.75 : 0.25), 2); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void bool4_independent() { var rnd = new Random(0x6E624EB7u); @@ -177,21 +177,21 @@ public static void bool4_independent() r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().zw))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => ((rnd.NextInt() & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => (((uint)rnd.NextInt() >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -199,7 +199,7 @@ public static void int_uniform_max() ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -207,7 +207,7 @@ public static void int_uniform_max_limit() ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -217,7 +217,7 @@ public static void int_uniform_min_max() ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), range); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -227,7 +227,7 @@ public static void int_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -235,7 +235,7 @@ public static void int2_uniform_low_bits() ks_test((() => ((rnd.NextInt2().y & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -243,7 +243,7 @@ public static void int2_uniform_high_bits() ks_test((() => (((uint)rnd.NextInt2().y >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -252,7 +252,7 @@ public static void int2_uniform_max() ks_test((() => (range_check(rnd.NextInt2(max).y, 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -263,7 +263,7 @@ public static void int2_uniform_min_max() ks_test((() => (range_check(rnd.NextInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -274,21 +274,21 @@ public static void int2_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt2(min, max).y, min, max) + 0.5 - min) / range), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_independent_low_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => (rnd.NextInt2().xy & 255)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int2_independent_high_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => ((uint2)rnd.NextInt2().xy >> 24)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -297,7 +297,7 @@ public static void int3_uniform_low_bits() ks_test((() => ((rnd.NextInt3().z & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -306,7 +306,7 @@ public static void int3_uniform_high_bits() ks_test((() => (((uint)rnd.NextInt3().z >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -316,7 +316,7 @@ public static void int3_uniform_max() ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max.z) + 0.5) / max.z), max.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -326,7 +326,7 @@ public static void int3_uniform_max_limit() ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -338,7 +338,7 @@ public static void int3_uniform_min_max() ks_test((() => (range_check(rnd.NextInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), range.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -350,7 +350,7 @@ public static void int3_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt3(min, max).z, min, max) + 0.5 - min) / range), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -359,7 +359,7 @@ public static void int3_independent_low_bits() r_test(() => (rnd.NextInt3().yz & 255)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int3_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -368,7 +368,7 @@ public static void int3_independent_high_bits() r_test(() => ((uint2)rnd.NextInt3().yz >> 24)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -378,7 +378,7 @@ public static void int4_uniform_low_bits() ks_test((() => ((rnd.NextInt4().w & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -388,7 +388,7 @@ public static void int4_uniform_high_bits() ks_test((() => (((uint)rnd.NextInt4().w >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -399,7 +399,7 @@ public static void int4_uniform_max() ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max.w) + 0.5) / max.w), max.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -410,7 +410,7 @@ public static void int4_uniform_max_limit() ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -423,7 +423,7 @@ public static void int4_uniform_min_max() ks_test((() => (range_check(rnd.NextInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), range.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -436,7 +436,7 @@ public static void int4_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextInt4(min, max).w, min, max) + 0.5 - min) / range), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -448,7 +448,7 @@ public static void int4_independent_low_bits() r_test(() => (rnd.NextUInt4().zw & 255)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void int4_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -461,21 +461,21 @@ public static void int4_independent_high_bits() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => ((rnd.NextUInt() & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => ((rnd.NextUInt() >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -483,7 +483,7 @@ public static void uint_uniform_max() ks_test((() => (rnd.NextUInt(max) + 0.5) / max), (int)max); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -491,7 +491,7 @@ public static void uint_uniform_max_limit() ks_test((() => (rnd.NextUInt(max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -501,7 +501,7 @@ public static void uint_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt(min, max), min, max) + 0.5 - min) / range), (int)range); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -509,7 +509,7 @@ public static void uint_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt(0, max), 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -517,7 +517,7 @@ public static void uint2_uniform_low_bits() ks_test((() => ((rnd.NextUInt2().y & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -525,7 +525,7 @@ public static void uint2_uniform_high_bits() ks_test((() => ((rnd.NextUInt2().y >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -534,7 +534,7 @@ public static void uint2_uniform_max() ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max.y), (int)max.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -543,7 +543,7 @@ public static void uint2_uniform_max_limit() ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -554,7 +554,7 @@ public static void uint2_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -563,21 +563,21 @@ public static void uint2_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt2(0, max).y, 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_independent_low_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => (rnd.NextUInt2().xy & 255)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint2_independent_high_bits() { var rnd = new Random(0x6E624EB7u); r_test(() => (rnd.NextUInt2().xy >> 24)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -586,7 +586,7 @@ public static void uint3_uniform_low_bits() ks_test((() => ((rnd.NextUInt3().z & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -595,7 +595,7 @@ public static void uint3_uniform_high_bits() ks_test((() => ((rnd.NextUInt3().z >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -605,7 +605,7 @@ public static void uint3_uniform_max() ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max.z), (int)max.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -615,7 +615,7 @@ public static void uint3_uniform_max_limit() ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -627,7 +627,7 @@ public static void uint3_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), (int)range.z); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -637,7 +637,7 @@ public static void uint3_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt3(0, max).z, 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -646,7 +646,7 @@ public static void uint3_independent_low_bits() r_test(() => (rnd.NextUInt3().yz & 255)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint3_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -655,7 +655,7 @@ public static void uint3_independent_high_bits() r_test(() => (rnd.NextUInt3().yz >> 24)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -665,7 +665,7 @@ public static void uint4_uniform_low_bits() ks_test((() => ((rnd.NextUInt4().w & 255u) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_uniform_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -675,7 +675,7 @@ public static void uint4_uniform_high_bits() ks_test((() => ((rnd.NextUInt4().w >> 24) + 0.5) / 256.0), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -686,7 +686,7 @@ public static void uint4_uniform_max() ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max.w), (int)max.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_uniform_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -697,7 +697,7 @@ public static void uint4_uniform_max_limit() ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -710,7 +710,7 @@ public static void uint4_uniform_min_max() ks_test((() => (range_check(rnd.NextUInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), (int)range.w); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_uniform_min_max_limit() { var rnd = new Random(0x6E624EB7u); @@ -721,7 +721,7 @@ public static void uint4_uniform_min_max_limit() ks_test((() => (range_check(rnd.NextUInt4(0, max).w, 0, max) + 0.5) / max), 256); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_independent_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -733,7 +733,7 @@ public static void uint4_independent_low_bits() r_test(() => (rnd.NextUInt4().zw & 255)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void uint4_independent_high_bits() { var rnd = new Random(0x6E624EB7u); @@ -745,21 +745,21 @@ public static void uint4_independent_high_bits() r_test(() => (rnd.NextUInt4().zw >> 24)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float_uniform() { var rnd = new Random(0x6E624EB7u); ks_test((() => range_check01(rnd.NextFloat()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => frac(rnd.NextFloat() * 65536.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -767,7 +767,7 @@ public static void float_uniform_max() ks_test((() => range_check(rnd.NextFloat(max), 0.0f, max) / max)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -777,7 +777,7 @@ public static void float_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat(min, max), min, max) -min) / range)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_uniform() { var rnd = new Random(0x6E624EB7u); @@ -785,7 +785,7 @@ public static void float2_uniform() ks_test((() => range_check01(rnd.NextFloat2().y))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -793,7 +793,7 @@ public static void float2_uniform_low_bits() ks_test((() => frac(rnd.NextFloat2().y * 65536.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -802,7 +802,7 @@ public static void float2_uniform_max() ks_test((() => range_check(rnd.NextFloat2(max).y, 0.0f, max.y) / max.y)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -813,14 +813,14 @@ public static void float2_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat2(min, max).y, min.y, max.y) - min.y) / range.y)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_independent() { var rnd = new Random(0x6E624EB7u); r_test((() => rnd.NextFloat2())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_uniform() { var rnd = new Random(0x6E624EB7u); @@ -829,7 +829,7 @@ public static void float3_uniform() ks_test((() => range_check01(rnd.NextFloat3().z))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -838,7 +838,7 @@ public static void float3_uniform_low_bits() ks_test((() => frac(rnd.NextFloat3().z * 65536.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -848,7 +848,7 @@ public static void float3_uniform_max() ks_test((() => range_check(rnd.NextFloat3(max).z, 0.0f, max.z) / max.z)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -860,7 +860,7 @@ public static void float3_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat3(min, max).z, min.z, max.z) - min.z) / range.z)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_independent() { var rnd = new Random(0x6E624EB7u); @@ -869,7 +869,7 @@ public static void float3_independent() r_test((() => rnd.NextFloat3().yz)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_uniform() { var rnd = new Random(0x6E624EB7u); @@ -879,7 +879,7 @@ public static void float4_uniform() ks_test((() => range_check01(rnd.NextFloat4().w))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -889,7 +889,7 @@ public static void float4_uniform_low_bits() ks_test((() => frac(rnd.NextFloat4().w * 65536.0f))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -900,7 +900,7 @@ public static void float4_uniform_max() ks_test((() => range_check(rnd.NextFloat4(max).w, 0.0f, max.w) / max.w)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -913,7 +913,7 @@ public static void float4_uniform_min_max() ks_test((() => (range_check(rnd.NextFloat4(min, max).w, min.w, max.w) - min.w) / range.w)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float4_independent() { var rnd = new Random(0x6E624EB7u); @@ -925,21 +925,21 @@ public static void float4_independent() r_test((() => rnd.NextFloat4().zw)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double_uniform() { var rnd = new Random(0x6E624EB7u); ks_test((() => range_check01(rnd.NextDouble()))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); ks_test((() => frac(rnd.NextDouble() * 35184372088832.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -947,7 +947,7 @@ public static void double_uniform_max() ks_test((() => range_check(rnd.NextDouble(max), 0.0, max) / max)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -957,7 +957,7 @@ public static void double_uniform_min_max() ks_test((() => (range_check(rnd.NextDouble(min, max), min, max) - min) / range)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_uniform() { var rnd = new Random(0x6E624EB7u); @@ -965,7 +965,7 @@ public static void double2_uniform() ks_test((() => range_check01(rnd.NextDouble2().y))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -973,7 +973,7 @@ public static void double2_uniform_low_bits() ks_test((() => frac(rnd.NextDouble2().y * 35184372088832.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -982,7 +982,7 @@ public static void double2_uniform_max() ks_test((() => range_check(rnd.NextDouble2(max).y, 0.0, max.y) / max.y)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -993,14 +993,14 @@ public static void double2_uniform_min_max() ks_test((() => (range_check(rnd.NextDouble2(min, max).y, min.y, max.y) - min.y) / range.y)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_independent() { var rnd = new Random(0x6E624EB7u); r_test((() => rnd.NextDouble2())); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_uniform() { var rnd = new Random(0x6E624EB7u); @@ -1009,7 +1009,7 @@ public static void double3_uniform() ks_test((() => range_check01(rnd.NextDouble3().z))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -1018,7 +1018,7 @@ public static void double3_uniform_low_bits() ks_test((() => frac(rnd.NextDouble3().z * 35184372088832.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -1028,7 +1028,7 @@ public static void double3_uniform_max() ks_test((() => range_check(rnd.NextDouble3(max).z, 0.0, max.z) / max.z)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -1041,7 +1041,7 @@ public static void double3_uniform_min_max() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_independent() { var rnd = new Random(0x6E624EB7u); @@ -1050,7 +1050,7 @@ public static void double3_independent() r_test((() => rnd.NextDouble3().yz)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_uniform() { var rnd = new Random(0x6E624EB7u); @@ -1060,7 +1060,7 @@ public static void double4_uniform() ks_test((() => range_check01(rnd.NextDouble4().w))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_uniform_low_bits() { var rnd = new Random(0x6E624EB7u); @@ -1070,7 +1070,7 @@ public static void double4_uniform_low_bits() ks_test((() => frac(rnd.NextDouble4().w * 35184372088832.0))); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_uniform_max() { var rnd = new Random(0x6E624EB7u); @@ -1081,7 +1081,7 @@ public static void double4_uniform_max() ks_test((() => range_check(rnd.NextDouble4(max).w, 0.0, max.w) / max.w)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_uniform_min_max() { var rnd = new Random(0x6E624EB7u); @@ -1094,7 +1094,7 @@ public static void double4_uniform_min_max() ks_test((() => (range_check(rnd.NextDouble4(min, max).w, min.w, max.w) - min.w) / range.w)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double4_independent() { var rnd = new Random(0x6E624EB7u); @@ -1106,7 +1106,7 @@ public static void double4_independent() r_test((() => rnd.NextDouble4().zw)); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float2_direction() { var rnd = new Random(0x6E624EB7u); @@ -1117,7 +1117,7 @@ public static void float2_direction() }); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double2_direction() { var rnd = new Random(0x6E624EB7u); @@ -1129,7 +1129,7 @@ public static void double2_direction() } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void float3_direction() { var rnd = new Random(0x6E624EB7u); @@ -1145,7 +1145,7 @@ public static void float3_direction() }); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void double3_direction() { var rnd = new Random(0x6E624EB7u); @@ -1161,7 +1161,7 @@ public static void double3_direction() }); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void quaternion_rotation() { var rnd = new Random(0x6E624EB7u); @@ -1183,7 +1183,7 @@ public static void quaternion_rotation() }); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void consecutive_seeds_r_test() { // Check that drawing 1 number from many consecutive seeds has no correlation. @@ -1195,7 +1195,7 @@ public static void consecutive_seeds_r_test() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void consecutive_seeds_r_test2() { // Check that drawing 1 number from many consecutive seeds has no correlation. @@ -1207,7 +1207,7 @@ public static void consecutive_seeds_r_test2() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void consecutive_seeds_ks_test() { // Check that drawing 1 number from many consecutive seeds matches our expected distribution. @@ -1215,7 +1215,7 @@ public static void consecutive_seeds_ks_test() ks_test(() => Random.CreateFromIndex(seed++).NextDouble()); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void consecutive_seeds_ks_test2() { // Check that drawing 1 number from many consecutive seeds matches our expected distribution. @@ -1223,7 +1223,7 @@ public static void consecutive_seeds_ks_test2() ks_test(() => Random.CreateFromIndex(seed++).NextDouble()); } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void similar_seeds() { // Check to see that two consecutive seeds have no correlation when drawing @@ -1236,7 +1236,7 @@ public static void similar_seeds() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void similar_seeds2() { // Check to see that two consecutive seeds have no correlation when drawing @@ -1249,7 +1249,7 @@ public static void similar_seeds2() } } - [TestCompiler /* For Burst testing */, TestCase /* For player builds */] + [TestCompiler] public static void wang_hash() { TestUtils.AreEqual(3232319850u, Random.WangHash(0u)); diff --git a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs index 778b2c25..c53afabc 100644 --- a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs +++ b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs @@ -2075,7 +2075,7 @@ private void BeginTest(StringBuilder str, string name, bool testCompiler = true) { if (testCompiler) { - str.Append("\t\t[TestCompiler /* For Burst testing */, TestCase /* For player builds */]\n"); + str.Append("\t\t[TestCompiler]\n"); } else { From 6a9b25e77840d5ad66c0bb52a7414287fbc341cc Mon Sep 17 00:00:00 2001 From: Scott Williams Date: Wed, 10 Jan 2024 16:13:21 -0800 Subject: [PATCH 35/50] Update bokken images for CI --- .yamato/upm-ci.yml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml index 2a554b38..9335ec46 100644 --- a/.yamato/upm-ci.yml +++ b/.yamato/upm-ci.yml @@ -1,28 +1,28 @@ build_platforms: - name: windows type: Unity::VM - image: sdet/burst-devimage:stable + image: package-ci/win10:v4 flavor: b1.large - name: linux - image: package-ci/ubuntu:stable + image: package-ci/ubuntu-22.04:v4 type: Unity::VM flavor: b1.large - name: macOS - image: burst/burst_mac:stable + image: package-ci/macos-13:v4 type: Unity::VM::osx flavor: b1.large upmci_platforms: - name: windows type: Unity::VM - image: package-ci/win10:stable + image: package-ci/win10:v4 flavor: b1.large - name: linux - image: package-ci/ubuntu:stable + image: package-ci/ubuntu-22.04:v4 type: Unity::VM flavor: b1.large - name: macOS - image: package-ci/mac:stable + image: package-ci/macos-13:v4 type: Unity::VM::osx flavor: b1.large @@ -85,7 +85,7 @@ package_tests_minimal: validate_package_minimal: name: Validate Package Linux Minimal agent: - image: package-ci/ubuntu:stable + image: package-ci/ubuntu-22.04:v4 type: Unity::VM flavor: b1.large commands: @@ -135,7 +135,7 @@ publish: name: Publish agent: type: Unity::VM - image: package-ci/win10:stable + image: package-ci/win10:v4 flavor: b1.large variables: UPMCI_ENABLE_PACKAGE_SIGNING: 1 @@ -158,7 +158,7 @@ promote: name: Promote agent: type: Unity::VM - image: package-ci/win10:stable + image: package-ci/win10:v4 flavor: b1.large variables: UPMCI_PROMOTION: 1 From 5fe7e8653c7285265eb3dfe5bee551b2a8c46b2e Mon Sep 17 00:00:00 2001 From: Scott Williams Date: Wed, 10 Jan 2024 16:46:19 -0800 Subject: [PATCH 36/50] Update package verification package and re-add internals visible to for testing --- .../Packages/manifest.json | 16 ++++++++-------- src/Unity.Mathematics/Properties/AssemblyInfo.cs | 5 +++++ .../Properties/AssemblyInfo.cs.meta | 11 +---------- 3 files changed, 14 insertions(+), 18 deletions(-) create mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs diff --git a/Unity.Mathematics.TestProject/Packages/manifest.json b/Unity.Mathematics.TestProject/Packages/manifest.json index e40c4a4b..932cc93d 100644 --- a/Unity.Mathematics.TestProject/Packages/manifest.json +++ b/Unity.Mathematics.TestProject/Packages/manifest.json @@ -1,15 +1,15 @@ { "dependencies": { - "com.unity.ai.navigation": "1.1.4", - "com.unity.burst": "1.8.7", - "com.unity.ide.rider": "3.0.24", - "com.unity.ide.visualstudio": "2.0.18", - "com.unity.ide.vscode": "1.2.5", + "com.unity.ai.navigation": "2.0.0", + "com.unity.burst": "1.8.11", + "com.unity.ide.rider": "3.0.27", + "com.unity.ide.visualstudio": "2.0.22", "com.unity.mathematics": "file:../../src", - "com.unity.package-validation-suite": "0.8.1-preview", + "com.unity.package-validation-suite": "0.62.0-preview", "com.unity.properties": "2.1.0-exp.3", - "com.unity.test-framework": "1.1.33", - "com.unity.test-framework.performance": "2.8.0-preview" + "com.unity.test-framework": "1.3.9", + "com.unity.test-framework.performance": "3.0.3", + "com.unity.modules.accessibility": "1.0.0" }, "testables": [ "com.unity.mathematics" diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..582cdee0 --- /dev/null +++ b/src/Unity.Mathematics/Properties/AssemblyInfo.cs @@ -0,0 +1,5 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")] +[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")] diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta b/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta index 8b36ead0..048f3093 100644 --- a/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta +++ b/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta @@ -1,11 +1,2 @@ fileFormatVersion: 2 -guid: 512db12834bb1f645a5c18af6c16e398 -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: +guid: fb0d7ffc71c40bd49a849e6427f80cb5 \ No newline at end of file From aa5b4ca36fce0c30c3c2e50d223f55f75b7c9945 Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Thu, 11 Jan 2024 10:34:23 -0800 Subject: [PATCH 37/50] prep for release --- src/CHANGELOG.md | 2 +- src/package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index f51a25d0..3cb929f3 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## [Unreleased] +## [1.3.2] - 2024-01-11 ### Fixed * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices. diff --git a/src/package.json b/src/package.json index 5e0509b2..f8870fc2 100755 --- a/src/package.json +++ b/src/package.json @@ -1,7 +1,7 @@ { "name": "com.unity.mathematics", "displayName": "Mathematics", - "version": "1.3.1", + "version": "1.3.2", "unity": "2018.3", "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.", "keywords": [ From 47ef6321a25c7ba609d4de0b45b0902f4eb9565d Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Thu, 11 Jan 2024 12:39:00 -0800 Subject: [PATCH 38/50] change minimum unity version --- src/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/package.json b/src/package.json index f8870fc2..9944d6fe 100755 --- a/src/package.json +++ b/src/package.json @@ -2,7 +2,7 @@ "name": "com.unity.mathematics", "displayName": "Mathematics", "version": "1.3.2", - "unity": "2018.3", + "unity": "2021.3", "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.", "keywords": [ "unity" From b7986ef8e6ce35cab339222b81027785e30a53c0 Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Thu, 11 Jan 2024 12:58:09 -0800 Subject: [PATCH 39/50] Update CHANGELOG.md --- src/CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 3cb929f3..484b5af3 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -5,6 +5,7 @@ ### Fixed * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices. * Fixed obsolete method usage warnings for `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` in UNITY_2023_2_OR_NEWER. +* Updated minimum editor version to 2021.3 ## [1.3.1] - 2023-07-12 From 1695a8503482a3131be78cc26308a93f82c05b04 Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Thu, 11 Jan 2024 14:31:59 -0800 Subject: [PATCH 40/50] update validation exceptions Need an exception due to us updating the minimum unity version to a supported Unity Version. --- src/ValidationExceptions.json | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json index e8a81512..3406ed9e 100644 --- a/src/ValidationExceptions.json +++ b/src/ValidationExceptions.json @@ -1,5 +1,10 @@ { "ErrorExceptions": [ + { + "ValidationTest": "Package Unity Version Validation", + "ExceptionMessage": "The Unity version requirement is more strict than in the previous version of the package. Increment the minor version of the package to leave patch versions available for previous version. Read more about this error and potential solutions at https://docs.unity3d.com/Packages/com.unity.package-validation-suite@latest/index.html?preview=1&subfolder=/manual/package_unity_version_validation_error.html#the-unity-version-requirement-is-more-strict-than-in-the-previous-version-of-the-package", + "PackageVersion": "1.3.2" + } ], "WarningExceptions": [] } \ No newline at end of file From 09c5980bd9588718743e64ace3b76f069486765e Mon Sep 17 00:00:00 2001 From: Gregory Labute Date: Fri, 15 Aug 2025 13:36:31 -0400 Subject: [PATCH 41/50] Update PostNormalizedVectorDrawer.cs tooltip display --- .../PostNormalizedVectorDrawer.cs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs b/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs index d4189eda..eaa2a07d 100644 --- a/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs +++ b/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs @@ -12,8 +12,10 @@ class PostNormalizedVectorDrawer : PrimitiveVectorDrawer { static class Content { - public static readonly string tooltip = - L10n.Tr("Values you enter will be post-normalized. You will see the normalized result if you change selection and view the values again."); + public static readonly GUIContent Tooltip = new ( + string.Empty, + L10n.Tr("Values you enter will be post-normalized. You will see the normalized result if you " + + "change selection and view the values again.")); } class VectorPropertyGUIData @@ -181,8 +183,12 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten return; } + // Avoid polluting the passed-in GUIContent - it might be static and shared. if (string.IsNullOrEmpty(label.tooltip)) - label.tooltip = Content.tooltip; + { + Content.Tooltip.text = label.text; + label = Content.Tooltip; + } guiData.RebuildIfDirty(); guiData.ApplyPreNormalizedValues(); From 4a423cc5dae8532391e57c37ab81dab12a64ea15 Mon Sep 17 00:00:00 2001 From: Gregory Labute Date: Mon, 25 Aug 2025 21:24:50 -0400 Subject: [PATCH 42/50] PrimitiveVectorDrawer doesn't change passed-in GUIContent (#251) * PrimitiveVectorDrawer doesn't change passed-in GUIContent * Update PrimitiveVectorDrawer.cs * Fix compile error. --------- Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com> --- src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs index cde01f38..5353bdcb 100644 --- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs +++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs @@ -36,8 +36,8 @@ static class Content public static readonly string doNotNormalizeCompatibility = L10n.Tr( $"{typeof(DoNotNormalizeAttribute).Name} only works with {typeof(quaternion)} and primitive vector types." ); - public static readonly string doNotNormalizeTooltip = - L10n.Tr("This value is not normalized, which may produce unexpected results."); + public static readonly GUIContent doNotNormalizeContent = new GUIContent("", + L10n.Tr("This value is not normalized, which may produce unexpected results.")); public static readonly GUIContent[] labels2 = { new GUIContent("X"), new GUIContent("Y") }; public static readonly GUIContent[] labels3 = { new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z") }; @@ -89,8 +89,10 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten } if (attribute is DoNotNormalizeAttribute && string.IsNullOrEmpty(label.tooltip)) - label.tooltip = Content.doNotNormalizeTooltip; - + { + Content.doNotNormalizeContent.text = label.text; + label = Content.doNotNormalizeContent; + } label = EditorGUI.BeginProperty(position, label, property); var valuesIterator = property.FindPropertyRelative(startIter); MultiPropertyField(position, subLabels, valuesIterator, label); From 00913ffa65b5a596a8c2b0700ae4bd715d3a1e44 Mon Sep 17 00:00:00 2001 From: Peter Lu <68305151+plu-unity@users.noreply.github.com> Date: Mon, 5 Jan 2026 17:42:31 -0500 Subject: [PATCH 43/50] Update upm-ci.yml to reflect currently supported editor versions for the package --- .yamato/upm-ci.yml | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml index 9335ec46..9b98958e 100644 --- a/.yamato/upm-ci.yml +++ b/.yamato/upm-ci.yml @@ -27,24 +27,24 @@ upmci_platforms: flavor: b1.large validate_editor_versions: - - version: "2021.3" - display_name: "2021.3" - version: "2022.3" display_name: "2022.3" - - version: "2023.1" - display_name: "2023.1" - - version: "trunk" - display_name: "trunk" + - version: "6000.0" + display_name: "6000.0" + - version: "6000.3" + display_name: "6000.3" + - version: "6000.4" + display_name: "6000.4" package_tests_editor_versions: - - version: "2021.3" - display_name: "2021.3" - version: "2022.3" display_name: "2022.3" - - version: "2023.1" - display_name: "2023.1" - - version: "trunk" - display_name: "trunk" + - version: "6000.0" + display_name: "6000.0" + - version: "6000.3" + display_name: "6000.3" + - version: "6000.4" + display_name: "6000.4" --- {% for platform in upmci_platforms %} From 3d6a653c29cfb4d2f54185b3832a985bed887222 Mon Sep 17 00:00:00 2001 From: Peter Lu <68305151+plu-unity@users.noreply.github.com> Date: Mon, 5 Jan 2026 23:26:13 -0500 Subject: [PATCH 44/50] Update some 2021.3 editor job dependencies in upm-ci.yml to 6000.3 --- .yamato/upm-ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml index 9b98958e..3675e42d 100644 --- a/.yamato/upm-ci.yml +++ b/.yamato/upm-ci.yml @@ -79,7 +79,7 @@ package_tests_minimal: name: Package tests minimal dependencies: {% for platform in upmci_platforms %} - - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2021.3 + - .yamato/upm-ci.yml#package_tests_{{platform.name}}_6000.3 {% endfor %} validate_package_minimal: @@ -91,7 +91,7 @@ validate_package_minimal: commands: - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g - upm-ci package pack --package-path src/ - - upm-ci package test --package-path src/ --unity-version 2021.3 + - upm-ci package test --package-path src/ --unity-version 6000.3 artifacts: packages: paths: From 4a4ece972005c927d6804ee6d6e4ff6961bff22d Mon Sep 17 00:00:00 2001 From: Peter Lu Date: Fri, 17 Jul 2026 20:04:29 -0400 Subject: [PATCH 45/50] Added a remark to NextFloatX and NextDoubleX methods with a min and max parameter. The affine (min, max) overloads compute the result as value * (max - min) + min. Floating-point rounding (round-half-to-even) can in rare cases return exactly max instead of a value strictly below it, so the [min, max) interval is the intent rather than a hard guarantee. --- src/Unity.Mathematics/random.cs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/Unity.Mathematics/random.cs b/src/Unity.Mathematics/random.cs index 3c94b6e3..a6c77d5c 100644 --- a/src/Unity.Mathematics/random.cs +++ b/src/Unity.Mathematics/random.cs @@ -468,6 +468,7 @@ public float4 NextFloat4() /// The minimum value to generate, inclusive. /// The maximum value to generate, exclusive. /// A uniformly random float value in the range [min, max). + /// The result is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a value equal to `max` rather than strictly less than it. Clamp the result if you require a value strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public float NextFloat(float min, float max) { return NextFloat() * (max - min) + min; } @@ -475,6 +476,7 @@ public float4 NextFloat4() /// The componentwise minimum value to generate, inclusive. /// The componentwise maximum value to generate, exclusive. /// A uniformly random float2 value in the range [min, max). + /// Each component is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public float2 NextFloat2(float2 min, float2 max) { return NextFloat2() * (max - min) + min; } @@ -482,6 +484,7 @@ public float4 NextFloat4() /// The componentwise minimum value to generate, inclusive. /// The componentwise maximum value to generate, exclusive. /// A uniformly random float3 value in the range [min, max). + /// Each component is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public float3 NextFloat3(float3 min, float3 max) { return NextFloat3() * (max - min) + min; } @@ -489,6 +492,7 @@ public float4 NextFloat4() /// The componentwise minimum value to generate, inclusive. /// The componentwise maximum value to generate, exclusive. /// A uniformly random float4 value in the range [min, max). + /// Each component is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public float4 NextFloat4(float4 min, float4 max) { return NextFloat4() * (max - min) + min; } @@ -572,6 +576,7 @@ public double4 NextDouble4() /// The minimum value to generate, inclusive. /// The maximum value to generate, exclusive. /// A uniformly random double value in the range [min, max). + /// The result is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a value equal to `max` rather than strictly less than it. Clamp the result if you require a value strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public double NextDouble(double min, double max) { return NextDouble() * (max - min) + min; } @@ -579,6 +584,7 @@ public double4 NextDouble4() /// The componentwise minimum value to generate, inclusive. /// The componentwise maximum value to generate, exclusive. /// A uniformly random double2 value in the range [min, max). + /// Each component is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public double2 NextDouble2(double2 min, double2 max) { return NextDouble2() * (max - min) + min; } @@ -586,6 +592,7 @@ public double4 NextDouble4() /// The componentwise minimum value to generate, inclusive. /// The componentwise maximum value to generate, exclusive. /// A uniformly random double3 value in the range [min, max). + /// Each component is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public double3 NextDouble3(double3 min, double3 max) { return NextDouble3() * (max - min) + min; } @@ -593,6 +600,7 @@ public double4 NextDouble4() /// The componentwise minimum value to generate, inclusive. /// The componentwise maximum value to generate, exclusive. /// A uniformly random double4 value in the range [min, max). + /// Each component is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`. [MethodImpl(MethodImplOptions.AggressiveInlining)] public double4 NextDouble4(double4 min, double4 max) { return NextDouble4() * (max - min) + min; } From f37f578a7cc32f599f96cdab007c88d12b6c8605 Mon Sep 17 00:00:00 2001 From: Peter Lu Date: Fri, 17 Jul 2026 20:06:27 -0400 Subject: [PATCH 46/50] -Added a unreleased changelog version and entry for the documentation port -Removed the ValidationExceptions.json entry needed for the last package release --- src/CHANGELOG.md | 3 +++ src/ValidationExceptions.json | 8 +------- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 484b5af3..595ffd52 100755 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -1,5 +1,8 @@ # Changelog +## [Unreleased] +* Added a documentation remark for Random NextFloat and NextDouble methods with a min and max parameter. + ## [1.3.2] - 2024-01-11 ### Fixed diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json index 3406ed9e..c9391d89 100644 --- a/src/ValidationExceptions.json +++ b/src/ValidationExceptions.json @@ -1,10 +1,4 @@ { - "ErrorExceptions": [ - { - "ValidationTest": "Package Unity Version Validation", - "ExceptionMessage": "The Unity version requirement is more strict than in the previous version of the package. Increment the minor version of the package to leave patch versions available for previous version. Read more about this error and potential solutions at https://docs.unity3d.com/Packages/com.unity.package-validation-suite@latest/index.html?preview=1&subfolder=/manual/package_unity_version_validation_error.html#the-unity-version-requirement-is-more-strict-than-in-the-previous-version-of-the-package", - "PackageVersion": "1.3.2" - } - ], + "ErrorExceptions": [], "WarningExceptions": [] } \ No newline at end of file From 6ffc2a46a14f4666ac19048356b57ebe3701ebea Mon Sep 17 00:00:00 2001 From: Peter Lu Date: Fri, 17 Jul 2026 20:09:43 -0400 Subject: [PATCH 47/50] Removing out of support editors from package validation YML --- .yamato/upm-ci.yml | 8 -------- 1 file changed, 8 deletions(-) diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml index 3675e42d..27b41405 100644 --- a/.yamato/upm-ci.yml +++ b/.yamato/upm-ci.yml @@ -27,24 +27,16 @@ upmci_platforms: flavor: b1.large validate_editor_versions: - - version: "2022.3" - display_name: "2022.3" - version: "6000.0" display_name: "6000.0" - version: "6000.3" display_name: "6000.3" - - version: "6000.4" - display_name: "6000.4" package_tests_editor_versions: - - version: "2022.3" - display_name: "2022.3" - version: "6000.0" display_name: "6000.0" - version: "6000.3" display_name: "6000.3" - - version: "6000.4" - display_name: "6000.4" --- {% for platform in upmci_platforms %} From 5141def0a12e24c58e565224971a52bd47ce62a9 Mon Sep 17 00:00:00 2001 From: Jonathan Mankin Date: Thu, 11 Jan 2024 14:31:59 -0800 Subject: [PATCH 48/50] update validation exceptions Need an exception due to us updating the minimum unity version to a supported Unity Version. --- src/ValidationExceptions.json | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json index c9391d89..3406ed9e 100644 --- a/src/ValidationExceptions.json +++ b/src/ValidationExceptions.json @@ -1,4 +1,10 @@ { - "ErrorExceptions": [], + "ErrorExceptions": [ + { + "ValidationTest": "Package Unity Version Validation", + "ExceptionMessage": "The Unity version requirement is more strict than in the previous version of the package. Increment the minor version of the package to leave patch versions available for previous version. Read more about this error and potential solutions at https://docs.unity3d.com/Packages/com.unity.package-validation-suite@latest/index.html?preview=1&subfolder=/manual/package_unity_version_validation_error.html#the-unity-version-requirement-is-more-strict-than-in-the-previous-version-of-the-package", + "PackageVersion": "1.3.2" + } + ], "WarningExceptions": [] } \ No newline at end of file From 045e4fb3cf48447eda190cba82ac7ad410c1a08c Mon Sep 17 00:00:00 2001 From: "christopher.sexton" Date: Wed, 5 Aug 2026 10:20:33 +0200 Subject: [PATCH 49/50] Fix copy-paste error in floor descriptions: round up -> down --- src/Unity.Mathematics/math.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs index a1b4800d..b17d04fe 100644 --- a/src/Unity.Mathematics/math.cs +++ b/src/Unity.Mathematics/math.cs @@ -2511,7 +2511,7 @@ public static bool4 ispow2(uint4 x) public static double4 asin(double4 x) { return new double4(asin(x.x), asin(x.y), asin(x.z), asin(x.w)); } - /// Returns the result of rounding a float value up to the nearest integral value less or equal to the original value. + /// Returns the result of rounding a float value down to the nearest integral value less or equal to the original value. /// Input value. /// The round down to nearest integral value of the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2536,7 +2536,7 @@ public static bool4 ispow2(uint4 x) public static float4 floor(float4 x) { return new float4(floor(x.x), floor(x.y), floor(x.z), floor(x.w)); } - /// Returns the result of rounding a double value up to the nearest integral value less or equal to the original value. + /// Returns the result of rounding a double value down to the nearest integral value less or equal to the original value. /// Input value. /// The round down to nearest integral value of the input. [MethodImpl(MethodImplOptions.AggressiveInlining)] From 73b0776667829a6b65d53a8e003ee8f2d241f8f4 Mon Sep 17 00:00:00 2001 From: "christopher.sexton" Date: Wed, 5 Aug 2026 14:04:35 +0200 Subject: [PATCH 50/50] Add notice on migration of docs from 6.5 --- src/Documentation~/index.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/Documentation~/index.md b/src/Documentation~/index.md index f158d0db..0b61abb2 100644 --- a/src/Documentation~/index.md +++ b/src/Documentation~/index.md @@ -16,6 +16,9 @@ Plus elementary functions: You can install the Mathematics package through Unity's Package Manager. For more information, see the Unity User Manual documentation on [Adding and removing packages](https://docs.unity3d.com/Manual/upm-ui-actions.html). +>[!IMPORTANT] +>From Unity 6.5, Unity Mathematics is a built-in module of the core Editor and Engine and its APIs are available to user code by default in the `Unity.Mathematics` namespace, with no package installation required. Accordingly, from Unity 6.5 the Unity Mathematics API documentation is part of the [core Scripting API reference](https://docs.unity3d.com/ScriptReference/Unity.Mathematics.math.html), and the user manual is integrated with [the core Unity user manual](https://docs.unity3d.com/Manual/unity-mathematics.html). + ### Editor config Unity Mathematics uses [editorconfig](http://editorconfig.org/) to keep files formatted for EOL and spaces.