Upload XRay Simulation

XRaySimulation-master/.gitignore

+[Dd]ebug/
+.vs/
+[Ll]ibrary/
+[Ll]ogs/
+[Pp]ackages/
+[Tt]emp/
+[Bb]uilds/
+*/[Bb]uild/
+*/[Bb]uild
+*.csproj
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Camera/CameraPerspectiveTest.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using NUnit.Framework;
+
+public class CameraPerspectiveTest
+{
+    private GameObject mockObj;
+
+    [SetUp]
+    public void Setup()
+    {
+        mockObj = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Player_Mock"));
+    }
+
+    [Test]
+    public void FPVisExistent_Test()
+    {
+        Transform fpvTransform = mockObj.transform.Find("FPV");
+
+        Assert.IsNotNull(fpvTransform);
+    }
+
+    [Test]
+    public void TPVisExistent_Test()
+    {
+        Transform tpvTransform = mockObj.transform.Find("TPV");
+
+        Assert.IsNotNull(tpvTransform);
+    }
+
+    [Test]
+    public void PlayerCameraScriptIsExistent_Test()
+    {
+        PlayerCamera pr = mockObj.GetComponent<PlayerCamera>();
+
+        Assert.IsNotNull(pr);
+    }
+
+    [Test]
+    public void WhenFPVisActiveInputSetsTPVActive_Test()
+    {
+        // setup
+        PlayerCamera pr = mockObj.GetComponent<PlayerCamera>();
+
+        // set the private CameraController field of PlayerCamera, since it is set in the Start-Method
+        System.Reflection.FieldInfo info = pr.GetType().GetField("cameraController", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        info.SetValue(pr, new FirstPersonCamera(pr.transform, 0f));
+
+        // perform
+        pr.SwitchCamera();
+
+        // get
+        bool FPV_isActive = mockObj.transform.Find("FPV").gameObject.activeSelf;
+        bool TPV_isActive = mockObj.transform.Find("TPV").gameObject.activeSelf;
+
+        // assert
+        Assert.IsTrue(TPV_isActive);
+        Assert.IsFalse(FPV_isActive);
+    }
+
+    [Test]
+    public void WhenTPVisActiveInputSetsFPVActive_Test()
+    {
+        // setup
+        PlayerCamera pr = mockObj.GetComponent<PlayerCamera>();
+        mockObj.transform.Find("FPV").gameObject.SetActive(false);
+        mockObj.transform.Find("TPV").gameObject.SetActive(true);
+
+        // set the CameraController field of PlayerCamera, since it is set in the Start-Method
+        System.Reflection.FieldInfo info = pr.GetType().GetField("cameraController", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        info.SetValue(pr, new ThirdPersonCamera(pr.transform, 0f));
+
+        // perform
+        pr.SwitchCamera();
+
+        // get
+        bool FPV_isActive = mockObj.transform.Find("FPV").gameObject.activeSelf;
+        bool TPV_isActive = mockObj.transform.Find("TPV").gameObject.activeSelf;
+
+        // assert
+        Assert.IsFalse(TPV_isActive);
+        Assert.IsTrue(FPV_isActive);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(mockObj);
+    }
+}

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Camera/FirstPersonCameraTest.cs

+using System;
+using UnityEngine;
+using NUnit.Framework;
+
+public class FirstPersonCameraTest
+{
+    public Transform Mock;
+    public Transform CameraTransform;
+    public FirstPersonCamera Controller;
+
+    private const float SPEED = 250f;
+
+    [SetUp]
+    public void SetUp()
+    {
+        // create player and camera mock
+        Mock = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Player_Mock")).transform;
+        CameraTransform = Mock.Find("FPV");
+
+        // First-Person-Camera
+        Controller = new FirstPersonCamera(Mock, 0f);
+
+        // set SPEED
+        System.Reflection.FieldInfo info = Controller.GetType().GetField("SPEED", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        info.SetValue(Controller, SPEED);
+    }
+
+    [Test]
+    public void PlayerCameraIsExistent_Test()
+    {
+        PlayerCamera pc = Mock.GetComponent<PlayerCamera>();
+
+        Assert.IsNotNull(pc);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MouseInputUPRotatesCameraUp_Test(float value)
+    {
+        // settup
+        Vector3 before = CameraTransform.rotation.eulerAngles;
+        
+        // perform
+        Controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = CameraTransform.rotation.eulerAngles;
+
+        // Move to test range.
+        // Since the Unity rotation is presented from 0 to 360 degrees.
+        // Which means a rotation is always greater than 0, or 0.
+        float afterX = after.x - 360f;
+
+        // assert
+        Assert.Less(afterX, before.x);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MouseInputDOWNRotatesCameraDown_Test(float value)
+    {
+        // setup
+        Vector3 before = CameraTransform.rotation.eulerAngles;
+        
+        // perform
+        Controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = CameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.Greater(after.x, before.x);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MouseInputRIGHTRotatesPlayerRight_Test(float value)
+    {
+        // setup
+        Vector3 before = Mock.rotation.eulerAngles;
+        
+        // perform
+        Controller.Rotate(value, 0f, 1f);
+        
+        // get
+        Vector3 after = Mock.rotation.eulerAngles;
+
+        // assert
+        Assert.Greater(after.y, before.y);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MouseInputLEFTRotatesPlayerLeft_Test(float value)
+    {
+        // setup
+        Vector3 before = Mock.rotation.eulerAngles;
+        
+        // perform
+        Controller.Rotate(value, 0f, 1f);
+        
+        // get
+        Vector3 after = Mock.rotation.eulerAngles;
+
+        // Move to test range.
+        // Since the Unity rotation is presented from 0 to 360 degrees.
+        // Which means a rotation is always greater than 0, or 0.
+        float afterY = after.y - 360f;
+
+        // assert
+        Assert.Less(afterY, before.y);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-1f)]
+    [TestCase(0f)]
+    public void ClampUpRotationForm60To60_Test(float value)
+    {
+        // setup
+        Controller.SetXRotation(60f);
+        Vector3 before = CameraTransform.localEulerAngles;
+        
+        // perform
+        Controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = CameraTransform.localEulerAngles;
+
+        after.x = (float)Math.Round(after.x, 10);
+
+        // assert
+        Assert.AreEqual(after.x, before.x);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-1f)]
+    [TestCase(0f)]
+    public void ClampUpRotationFormLess60To60_Test(float value)
+    {
+        // setup
+        Controller.SetXRotation(59f);
+        Vector3 before = CameraTransform.localEulerAngles;
+        
+        // perform
+        Controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = CameraTransform.localEulerAngles;
+
+        after.x = (float) Math.Round(after.x, 3);
+
+        // assert
+        Assert.GreaterOrEqual(after.x, 59f);
+        Assert.LessOrEqual(after.x, 60f);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(1f)]
+    [TestCase(0f)]
+    public void ClampDownRotationFormMinus60ToMinus60_Test(float value)
+    {
+        // setup
+        Controller.SetXRotation(-60f);
+        Vector3 before = CameraTransform.localEulerAngles;
+        
+        // perform
+        Controller.Rotate(0f, value, 1f);
+
+        // get
+        Vector3 after = CameraTransform.localEulerAngles;
+
+        after.x = (float)Math.Round(after.x, 10);
+
+        // assert
+        Assert.AreEqual(after.x, before.x);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(1f)]
+    [TestCase(0f)]
+    public void ClampDownRotationFormLessMinus60ToMinus60_Test(float value)
+    {
+        // setup
+        Controller.SetXRotation(-59f);
+        Vector3 before = CameraTransform.localEulerAngles;
+        
+        // perform
+        Controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = CameraTransform.localEulerAngles;
+
+        // Move to test range.
+        // Since the Unity rotation is presented from 0 to 360 degrees.
+        // Which means a rotation is always greater than 0, or 0.
+        float afterX = after.x - 360f;
+
+        // assert
+        Assert.LessOrEqual(afterX, -59f);
+        Assert.GreaterOrEqual(afterX, -60f);
+    }
+
+    [Test]
+    [TestCase(0f)]
+    [TestCase(10f)]
+    [TestCase(-130f)]
+    [TestCase(1f)]
+    [TestCase(-0.0010f)]
+    public void ReturnsCorrectYRotation_Test(float value)
+    {
+        // perform
+        Controller.Rotate(value, 0f, 1f);
+        
+        // get
+        float after = Controller.GetYRotation();
+
+        // assert
+        // value * 250, since the rotationspeed is set to 250
+        Assert.AreEqual(value * SPEED, after);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(Mock.gameObject);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Camera/MeshCameraTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class MeshCameraTest
+{
+    private Transform mock;
+    private Transform cameraTransform;
+    private MeshCamera controller;
+
+    private const float SPEED = 250f;
+
+    [SetUp]
+    public void SetUp()
+    {
+        // create player and camera mock
+        mock = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Player_Mock")).transform;
+        cameraTransform = mock.Find("MeshCamera");
+
+        // mesh camera
+        controller = new MeshCamera(cameraTransform, 0f);
+
+        //Set SPEED const
+        System.Reflection.FieldInfo info = controller.GetType().GetField("SPEED", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        info.SetValue(controller, SPEED);
+    }
+
+    [Test]
+    public void PlayerCameraIsExistent_Test()
+    {
+        PlayerCamera pc = mock.GetComponent<PlayerCamera>();
+
+        Assert.IsNotNull(pc);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MouseInputUPRotatesCameraDown_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+
+        // since the desired rotation is clamped
+        expected = Mathf.Clamp(expected, -60, 60);
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = 360f - expected;
+
+        // perform
+        controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = cameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, (float)Math.Round(after.x, 3));
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MouseInputDOWNRotatesCameraUp_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+
+        // since the desired rotation is clamped
+        expected = Mathf.Clamp(expected, -60, 60);
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = -expected;
+
+        // perform
+        controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = cameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, (float)Math.Round(after.x, 3));
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MouseInputRIGHTRotatesCameraRight_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+
+        // perform
+        controller.Rotate(value, 0f, 1f);
+        
+        // get
+        Vector3 after = cameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, after.y);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MouseInputLEFTRotatesPlayerLeft_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+        // since Unity returns rotations form 0 to 360 degrees
+        expected = 360f + expected;
+
+        // perform
+        controller.Rotate(value, 0f, 1f);
+        
+        // get
+        Vector3 after = cameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, after.y);
+    }
+
+    [Test]
+    [TestCase(0f)]
+    [TestCase(10f)]
+    [TestCase(-130f)]
+    [TestCase(1f)]
+    [TestCase(-0.0010f)]
+    public void ReturnsCorrectYRotation_Test(float value)
+    {
+        // perform
+        controller.Rotate(value, 0f, 1f);
+        
+        // get
+        float after = controller.GetYRotation();
+
+        // assert
+        Assert.AreEqual(value * SPEED, after);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(mock.gameObject);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Camera/ThirdPersonCameraTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class ThirdPersonCameraTest
+{
+    private Transform mock;
+    private Transform cameraTransform;
+    private ThirdPersonCamera controller;
+
+    private const float SPEED = 250f; 
+
+    [SetUp]
+    public void SetUp()
+    {
+        // create player and camera mock
+        GameObject prefab = Resources.Load<GameObject>("Prefabs/Player_Mock");
+        mock = GameObject.Instantiate(prefab).transform;
+        cameraTransform = mock.Find("TPV");
+
+        // Third-Person-Controller
+        controller = new ThirdPersonCamera(mock, 0f);
+
+        //Set SPEED const
+        System.Reflection.FieldInfo info = controller.GetType().GetField("SPEED", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        info.SetValue(controller, SPEED);
+    }
+
+    [Test]
+    public void PlayerCameraIsExistent_Test()
+    {
+        PlayerCamera pc = mock.GetComponent<PlayerCamera>();
+        
+        Assert.IsNotNull(pc);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MouseInputUPRotatesCameraDown_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+
+        // since the desired rotation is clamped
+        expected = Mathf.Clamp(expected, -60, 60);
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = 360f - expected;
+
+        // perform
+        controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = cameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, (float)Math.Round(after.x, 3));
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MouseInputDOWNRotatesCameraUp_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+
+        // since the desired rotation is clamped
+        expected = Mathf.Clamp(expected, -60, 60);
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = -expected;
+
+        // perform
+        controller.Rotate(0f, value, 1f);
+        
+        // get
+        Vector3 after = cameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, (float) Math.Round(after.x, 3));
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MouseInputRIGHTRotatesPlayerRight_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+
+        // perform
+        controller.Rotate(value, 0f, 1f);
+        
+        // get
+        Vector3 after = mock.transform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, after.y);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MouseInputLEFTRotatesPlayerLeft_Test(float value)
+    {
+        // setup
+        float expected = value * 1f * SPEED;
+        // since Unity returns rotations form 0 to 360 degrees
+        expected = 360f + expected;
+
+        // perform
+        controller.Rotate(value, 0f, 1f);
+        
+        // get
+        Vector3 after = mock.transform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, after.y);
+    }
+
+    [Test]
+    [TestCase(0f)]
+    [TestCase(10f)]
+    [TestCase(-130f)]
+    [TestCase(1f)]
+    [TestCase(-0.0010f)]
+    public void ReturnsCorrectYRotation_Test(float value)
+    {
+        // perform
+        controller.Rotate(value, 0f, 1f);
+        
+        // get
+        float after = controller.GetYRotation();
+
+        // assert
+        Assert.AreEqual(value * SPEED, after);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(mock.gameObject);
+        controller = null;
+    }
+}

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/DoseInfo/DoseInfoControllerTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class DoseInfoControllerTest
+{
+    private Transform doseInfoTransform;
+    private DoseInfoController controller;
+    private Transform meshCameraTransform;
+
+    [SetUp]
+    public void SetUp()
+    {
+        // instantiate the UI DoseInfo
+        GameObject prefab = Resources.Load<GameObject>("Prefabs/UI/DoseInfo");
+        doseInfoTransform = GameObject.Instantiate(prefab).transform;
+
+        // create a mesh camera mock
+        meshCameraTransform = GameObject.Instantiate(new GameObject("MeshCamera")).transform;
+        controller = new DoseInfoController(doseInfoTransform, meshCameraTransform);
+    }
+
+    /// <summary>
+    /// Enables to get the value of a private field with given name.
+    /// Returns the value of the field.
+    /// </summary>
+    private T GetPrivateField<T>(string fieldName)
+    {
+        System.Reflection.FieldInfo info = controller.GetType().GetField(fieldName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        return (T)info.GetValue(controller);
+    }
+
+    [Test]
+    public void ControllerIsNotNull_Test()
+    {
+        Assert.IsNotNull(controller);
+    }
+
+    [Test]
+    public void DoseInfoTransformIsNotNull_Test()
+    {
+        Transform transform = GetPrivateField<Transform>("infoTransform");
+
+        Assert.IsNotNull(transform);
+    }
+
+    [Test]
+    public void DoseInfoTransformIsCorrectTransform_Test()
+    {
+        Transform transform = GetPrivateField<Transform>("infoTransform");
+
+        Assert.AreEqual(doseInfoTransform, transform);
+    }
+
+    [Test]
+    public void MeshCameraTransformIsNotNull_Test()
+    {
+        Transform transform = GetPrivateField<Transform>("meshCameraTransform");
+
+        Assert.IsNotNull(transform);
+    }
+
+    [Test]
+    public void MeshCameraTransformIsCorrectTransform_Test()
+    {
+        Transform transform = GetPrivateField<Transform>("meshCameraTransform");
+
+        Assert.AreEqual(meshCameraTransform, transform);
+    }
+
+    [Test]
+    public void AVGTextMeshIsNotNull_Test()
+    {
+        TextMeshProUGUI textMesh = GetPrivateField<TextMeshProUGUI>("avgTextMesh");
+
+        Assert.IsNotNull(textMesh);
+    }
+
+    [Test]
+    public void SourceActiveTextMeshIsNotNull_Test()
+    {
+        TextMeshProUGUI textMesh = GetPrivateField<TextMeshProUGUI>("activeTextMesh");
+
+        Assert.IsNotNull(textMesh);
+    }
+
+    [Test]
+    public void CameraControllerIsNotNull_Test()
+    {
+        MeshCamera camera = GetPrivateField<MeshCamera>("cameraController");
+
+        Assert.IsNotNull(camera);
+    }
+
+    [Test]
+    public void SetAVGDose_Test()
+    {
+        // setup
+        float dose = 10f;
+        string expected = dose + " Gy";
+
+        // perform
+        controller.SetAVGDose(dose);
+
+        // get
+        TextMeshProUGUI textMesh = doseInfoTransform.Find("AVG Dose").GetComponent<TextMeshProUGUI>();
+        string actual = textMesh.text;
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    private const float SPEED = 250f;
+
+    [Test]
+    public void ArrowUPRotatesMeshCameraUp_Test()
+    {
+        // setup
+        float expected = 1f * SPEED;
+
+        // since the desired rotation is clamped
+        expected = Mathf.Clamp(expected, -60, 60);
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = 360f - expected;
+
+        //perform
+        controller.Rotate(0f, 1f, 1f);
+
+        // get
+        Vector3 after = meshCameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, (float)Math.Round(after.x, 3));
+    }
+
+    [Test]
+    public void ArrowDOWNRotatesMeshCameraDown_Test()
+    {
+        // setup
+        float expected = -1f * SPEED;
+
+        // since the desired rotation is clamped
+        expected = Mathf.Clamp(expected, -60, 60);
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = -expected;
+
+        // perform
+        controller.Rotate(0f, -1f, 1f);
+
+        //get
+        Vector3 after = meshCameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, (float)Math.Round(after.x, 3));
+    }
+
+    [Test]
+    public void ArrowRIGHTRotatesMeshCameraRight_Test()
+    {
+        // setup
+        float expected = 1f * SPEED;
+
+        // perform
+        controller.Rotate(1f, 0f, 1f);
+
+        // get
+        Vector3 after = meshCameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, after.y);
+    }
+
+    [Test]
+    public void ArrowLEFTRotatesMeshCameraLeft_Test()
+    {
+        // setup
+        float expected = -1f * SPEED;
+        // because Unity returns rotations from 0 to 360 degrees
+        expected = 360 + expected;
+
+        // perform
+        controller.Rotate(-1f, 0f, 1f);
+
+        // get
+        Vector3 after = meshCameraTransform.rotation.eulerAngles;
+
+        // assert
+        Assert.AreEqual(expected, after.y);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(doseInfoTransform.gameObject);
+        GameObject.DestroyImmediate(meshCameraTransform.gameObject);
+        controller = null;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/DoorControllerTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class DoorControllerTest
+{
+    private GameObject testObj;
+    private Furniture furniture;
+    private FurnitureController controller;
+
+    [SetUp]
+    public void SetUp()
+    {
+        // door mock
+        GameObject prefab = Resources.Load<GameObject>("Prefabs/Door");
+        testObj = GameObject.Instantiate(prefab);
+        testObj.name = "Door";
+
+        furniture = testObj.GetComponent<Furniture>();
+        controller = new DoorController(testObj.transform);
+    }
+
+    /// <summary>
+    /// Enables to get the value of a private field with given name.
+    /// Returns the value of the field.
+    /// </summary>
+    private T GetPrivateField<T>(string fieldName)
+    {
+        System.Reflection.FieldInfo info = controller.GetType().GetField(fieldName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        return (T)info.GetValue(controller);
+    }
+
+    [Test]
+    public void TestObjectIsNotNull_Test()
+    {
+        Assert.IsNotNull(testObj);
+    }
+
+    [Test]
+    public void FurnitrueIsNotNull_Test()
+    {
+        Assert.IsNotNull(furniture);
+    }
+
+    [Test]
+    public void ControllerIsNotNull_Test()
+    {
+        Assert.IsNotNull(controller);
+    }
+
+    [Test]
+    public void LeftDoorIsNotNull_Test()
+    {
+        Transform left = GetPrivateField<Transform>("leftDoor");
+
+        Assert.IsNotNull(left);
+    }
+
+    [Test]
+    public void RightDoorIsNotNull_Test()
+    {
+        Transform right = GetPrivateField<Transform>("rightDoor");
+
+        Assert.IsNotNull(right);
+    }
+
+    [Test]
+    [TestCase(new bool[] { })]
+    [TestCase(new bool[] { true, true })]
+    [TestCase(new bool[] { false, false })]
+    public void NothingWillHappenWhenWrongAmountOfInstructionsGiven_Test(bool[] instructions)
+    {
+        // perform
+        controller.Interact(instructions, 1f);
+
+        // get
+        bool isOpen = GetPrivateField<bool>("isOpen");
+
+        // assert
+        Assert.IsFalse(isOpen);
+    }
+
+    [Test]
+    public void FirstPressOfFWillSetIsOpenToTrue_Test()
+    {
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // get
+        bool isOpen = GetPrivateField<bool>("isOpen");
+
+        // assert
+        Assert.IsTrue(isOpen);
+    }
+
+    [Test]
+    public void SecondPressOfFWillSetIsOpenFalse_Test()
+    {
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+        controller.Interact(new bool[] { true }, 1f);
+
+        // get
+        bool isOpen = GetPrivateField<bool>("isOpen");
+
+        // assert
+        Assert.IsFalse(isOpen);
+    }
+
+    [Test]
+    public void FirstPressOfFWillOpenDoor_Test()
+    {
+        // setup
+        Transform left = GetPrivateField<Transform>("leftDoor");
+        Transform right = GetPrivateField<Transform>("rightDoor");
+
+        Vector3 leftBefore = left.localPosition;
+        Vector3 rightBefore = right.localPosition;
+
+        // perform
+        controller.Interact(new bool[] { true }, 1);
+
+        // get
+        Vector3 leftAfter = left.localPosition;
+        Vector3 rightAfter = right.localPosition;
+
+        // assert
+        Assert.Less(leftAfter.z, leftBefore.z);
+        Assert.Greater(rightAfter.z, rightBefore.z);
+    }
+
+    [Test]
+    public void SecondPressOfFWillCloseDoor_Test()
+    {
+        // setup
+        Transform left = GetPrivateField<Transform>("leftDoor");
+        Transform right = GetPrivateField<Transform>("rightDoor");
+
+        Vector3 leftBefore = left.localPosition;
+        Vector3 rightBefore = right.localPosition;
+
+        // perform
+        controller.Interact(new bool[] { true }, 1);
+        controller.Interact(new bool[] { true }, 1);
+
+        // get
+        Vector3 leftAfter = left.localPosition;
+        Vector3 rightAfter = right.localPosition;
+
+        // assert
+        Assert.AreEqual(leftAfter.z, leftBefore.z);
+        Assert.AreEqual(rightAfter.z, rightBefore.z);
+    }
+
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(testObj);
+        controller = null;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/FurnitureControllerFactoryTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class FurnitureControllerFactoryTest
+{
+    [Test]
+    public void FactoryReturnIsNotNull_Test()
+    { 
+        // setup
+        GameObject obj = new GameObject();
+
+        // perform
+        FurnitureController controller = FurnitureControllerFactory.Create(FurnitureType.None, obj.transform);
+
+        // assert
+        Assert.IsNotNull(controller);
+    }
+
+    [Test]
+    [TestCase(typeof(PatientTableController), FurnitureType.PatientTable)]
+    [TestCase(typeof(MoveableController), FurnitureType.ProtectionWall)]
+    [TestCase(typeof(MoveableController), FurnitureType.Table)]
+    public void ReturnedControllerIsOfCorrectType_Test(Type type, FurnitureType furnitureType)
+    {
+        // setup
+        GameObject obj = new GameObject();
+        
+        // perform
+        FurnitureController controller = FurnitureControllerFactory.Create(furnitureType, obj.transform);
+
+        // assert
+        Assert.AreEqual(type, controller.GetType());
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/FurnitureInfoTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class FurnitureInfoTest
+{
+    [Test]
+    public void EmptyConstructorName_Test()
+    {
+        FurnitureInfo info = new FurnitureInfo();
+
+        Assert.IsNotNull(info.Name);
+    }
+
+    [Test]
+    public void EmptyConstructorDescription_Test()
+    {
+        FurnitureInfo info = new FurnitureInfo();
+
+        Assert.IsNotNull(info.Description);
+    }
+
+    [Test]
+    public void EmptyConstructorKeyCodes_Test()
+    {
+        FurnitureInfo info = new FurnitureInfo();
+
+        Assert.IsNotNull(info.KeyCodes);
+    }
+
+    [Test]
+    [TestCase("", "You are able to move it around!", new KeyCode[] { KeyCode.F })]
+    [TestCase("Table", "You are able to move it around!", new KeyCode[] {KeyCode.F})]
+    public void ConstructorName_Test(string expected, string description, KeyCode[] keys)
+    {
+        FurnitureInfo info = new FurnitureInfo(expected, description, keys);
+
+        Assert.AreEqual(expected, info.Name);
+    }
+
+    [Test]
+    [TestCase("Table", "", new KeyCode[] { KeyCode.F })]
+    [TestCase("Table", "You are able to move it around!", new KeyCode[] { KeyCode.F })]
+    public void ConstructorDescription_Test(string name, string expected, KeyCode[] keys)
+    {
+        FurnitureInfo info = new FurnitureInfo(name, expected, keys);
+
+        Assert.AreEqual(expected, info.Description);
+    }
+
+    [Test]
+    [TestCase("Table", "You are able to move it around!", new KeyCode[] { })]
+    [TestCase("Table", "You are able to move it around!", new KeyCode[] { KeyCode.F })]
+    [TestCase("Table", "You are able to move it around!", new KeyCode[] { KeyCode.F, KeyCode.A })]
+    public void ConstructorKeyCodes_Test(string name, string description, KeyCode[] expected)
+    {
+        FurnitureInfo info = new FurnitureInfo(name, description, expected);
+
+        Assert.AreEqual(expected, info.KeyCodes);
+    }
+
+    /// <summary>
+    /// To Check if the FurnitureInfo can be set in the inspector.
+    /// </summary>
+    [Test]
+    public void IsSerializeable_Test()
+    {
+        Assert.IsTrue(typeof(FurnitureInfo).IsSerializable);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/FurnitureTriggerInfoTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using TMPro;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+public class FurnitureTriggerInfoTest
+{
+    private GameObject gui;
+
+    [SetUp]
+    public void Setup()
+    {
+        // create a GUI object
+        GameObject prefab = Resources.Load<GameObject>("Prefabs/UI/GUI");
+        gui = GameObject.Instantiate(prefab);
+        gui.name = "GUI";
+    }
+
+    [Test]
+    [TestCase(FurnitureType.CArm)]
+    [TestCase(FurnitureType.Closet)]
+    [TestCase(FurnitureType.Door)]
+    [TestCase(FurnitureType.PatientTable)]
+    [TestCase(FurnitureType.ProtectionWall)]
+    [TestCase(FurnitureType.Table)]
+    [TestCase(FurnitureType.None)]
+    public void SetActiveFurnitureSetsCorrectFurnitureType_Test(FurnitureType expected)
+    {
+        // setup
+        FurnitureInfo info = new FurnitureInfo(expected.ToString(), expected.ToString(), new KeyCode[] { });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(expected, info);
+
+        // assert
+        Assert.AreEqual(expected, FurnitureTriggerInfo.Type);
+    }
+
+    [Test]
+    public void DeactivateFunitureSetsTypeToNone_Test()
+    {
+        // setup
+        FurnitureTriggerInfo.Type = FurnitureType.CArm;
+
+        // perform
+        FurnitureTriggerInfo.DeactivateFurniture();
+
+        // assert
+        Assert.AreEqual(FurnitureType.None, FurnitureTriggerInfo.Type);
+    }
+
+    [Test]
+    public void SetActiveFurnitureActivatesFurnitureInfoUI_Test()
+    {
+        // setup
+        FurnitureInfo info = new FurnitureInfo("example", "example", new KeyCode[] { });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(FurnitureType.CArm, info);
+
+        // get
+        bool active = GameObject.Find("GUI/FurnitureInfo").activeSelf;
+
+        // assert
+        Assert.IsTrue(active);
+    }
+
+    [Test]
+    public void DeactivateFurnitureDeactivatesFurnitureInfoUI_Test()
+    {
+        // perform
+        FurnitureTriggerInfo.DeactivateFurniture();
+
+        // get
+        bool active = GameObject.Find("GUI").transform.Find("FurnitureInfo").gameObject.activeSelf;
+
+        // assert
+        Assert.IsFalse(active);
+    }
+
+    [Test]
+    [TestCase(FurnitureType.CArm)]
+    public void SetActiveFurnitureLoadsCorrectFurnitureNameIntoUI_Test(FurnitureType type)
+    {
+        // setup
+        string expected = type.ToString();
+        FurnitureInfo info = new FurnitureInfo(expected, expected, new KeyCode[] { });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(type, info);
+
+        // get
+        string actual = GameObject.Find("GUI/FurnitureInfo/Name").GetComponent<TextMeshProUGUI>().text;
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(FurnitureType.CArm)]
+    public void SetActiveFurnitureLoadsCorrectFurnitureDescriptionIntoUI_Test(FurnitureType type)
+    {
+        // setup
+        string expected = type.ToString();
+        FurnitureInfo info = new FurnitureInfo(expected, expected, new KeyCode[] { });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(type, info);
+
+        //get
+        string actual = GameObject.Find("GUI/FurnitureInfo/Description").GetComponent<TextMeshProUGUI>().text;
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(FurnitureType.CArm, new KeyCode[] { KeyCode.A, KeyCode.F })]
+    [TestCase(FurnitureType.CArm, new KeyCode[] { KeyCode.B, KeyCode.DownArrow })]
+    public void SetActiveFurnitureLoadsCorrectKeyCodesIntoUIForTwoKeys_Test(FurnitureType type, KeyCode[] keys)
+    {
+        // setup
+        string expected = type.ToString();
+        FurnitureInfo info = new FurnitureInfo(expected, expected, keys);
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(type, info);
+
+        // get
+        string actual0 = GameObject.Find("GUI/FurnitureInfo/Keys/1/KeyName").GetComponent<TextMeshProUGUI>().text;
+        string actual1 = GameObject.Find("GUI/FurnitureInfo/Keys/2/KeyName").GetComponent<TextMeshProUGUI>().text;
+
+        // assert
+        Assert.AreEqual(keys[0].ToString(), actual0);
+        Assert.AreEqual(keys[1].ToString(), actual1);
+    }
+
+    [Test]
+    [TestCase(FurnitureType.CArm, KeyCode.A)]
+    [TestCase(FurnitureType.Table, KeyCode.DownArrow)]
+    public void SetActiveFurnitureLoadsCorrectKeyCodesIntoUIForOneKey_Test(FurnitureType type, KeyCode keyCode)
+    {
+        // setup
+        string expected = keyCode.ToString();
+        string name = type.ToString();
+        FurnitureInfo info = new FurnitureInfo(name, name, new KeyCode[] { keyCode });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(FurnitureType.CArm, info);
+
+        // get
+        string actual0 = GameObject.Find("GUI/FurnitureInfo/Keys/1/KeyName").GetComponent<TextMeshProUGUI>().text;
+        string actual1 = GameObject.Find("GUI/FurnitureInfo/Keys/2/KeyName").GetComponent<TextMeshProUGUI>().text;
+
+        // assert
+        Assert.AreEqual(expected, actual0);
+        Assert.AreEqual("", actual1);
+    }
+
+    [Test]
+    [TestCase(FurnitureType.CArm)]
+    [TestCase(FurnitureType.Table)]
+    public void SetActiveFurnitureLoadsCorrectKeyCodesIntoUIForZeroKeys_Test(FurnitureType type)
+    {
+        // setup
+        string expected = "";
+        string name = type.ToString();
+        FurnitureInfo info = new FurnitureInfo(name, name, new KeyCode[] {  });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(FurnitureType.CArm, info);
+
+        // get
+        string actual0 = GameObject.Find("GUI/FurnitureInfo/Keys/1/KeyName").GetComponent<TextMeshProUGUI>().text;
+        string actual1 = GameObject.Find("GUI/FurnitureInfo/Keys/2/KeyName").GetComponent<TextMeshProUGUI>().text;
+
+        // assert
+        Assert.AreEqual(expected, actual0);
+        Assert.AreEqual(expected, actual1);
+    }
+
+    [Test]
+    public void SetActiveFurnitureThrowsWarningMessageWhenFurnitureInfoHasMoreThanTwoKeyCodes_Test()
+    {
+        // setup
+        FurnitureInfo info = new FurnitureInfo("example", "example", new KeyCode[] { KeyCode.A, KeyCode.B, KeyCode.C });
+
+        // perform
+        FurnitureTriggerInfo.SetActiveFurniture(FurnitureType.CArm, info);
+
+        // assert
+        LogAssert.Expect(LogType.Warning, "The GUI can only handle two different keys!");
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(gui);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/MoveableControllerTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class MoveableControllerTest
+{
+    private GameObject testObj;
+    private Furniture furniture;
+    private FurnitureController controller;
+
+    [SetUp]
+    public void Setup()
+    {
+        // mobile table mock
+        testObj = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/mobileTable"));
+        testObj.name = "mobileTable";
+
+        furniture = testObj.GetComponent<Furniture>();
+        controller = new MoveableController(testObj.transform);
+    }
+
+    private GameObject CreatePlayerMock()
+    {
+        GameObject player = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Player_Mock"));
+        player.name = "Player";
+
+        return player;
+    }
+
+    [Test]
+    public void TestObjectIsNotNull_Test()
+    {
+        Assert.IsNotNull(testObj);
+    }
+
+    [Test]
+    public void FurnitrueIsNotNull_Test()
+    {
+        Assert.IsNotNull(furniture);
+    }
+
+    [Test]
+    public void ControllerIsNotNull_Test()
+    {
+        Assert.IsNotNull(controller);
+    }
+
+    [Test]
+    [TestCase(new bool[] { })]
+    [TestCase(new bool[] { true, true})]
+    [TestCase(new bool[] { false, false })]
+    public void NothingWillHappenWhenWronAmountOfInstructionsGiven_Test(bool[] instructions)
+    {
+        // setup
+        GameObject playerObj = CreatePlayerMock();
+
+        // perform
+        controller.Interact(instructions, 1f);
+
+        // assert
+        Assert.IsNull(playerObj.transform.Find("mobileTable"));
+
+        // cleanup
+        GameObject.DestroyImmediate(playerObj);
+    }
+
+    [Test]
+    public void FirstPressFWillLockTheTableToThePlayerMovementWhenIsTriggered_Test()
+    {
+        // setup
+        GameObject playerObj = CreatePlayerMock();
+
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // assert
+        Assert.IsNotNull(playerObj.transform.Find("mobileTable"));
+
+        // cleanup
+        GameObject.DestroyImmediate(playerObj);
+    }
+
+    [Test]
+    public void SecondPressFWillReleaseTheTableFromThePlayerMovementWhenIsTriggerd_Test()
+    {
+        // setup
+        GameObject playerObj = CreatePlayerMock();
+
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // assert
+        Assert.IsNotNull(playerObj.transform.Find("mobileTable"));
+
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // assert
+        Assert.IsNull(playerObj.transform.Find("mobileTable"));
+        Assert.IsNotNull(GameObject.Find("mobileTable"));
+
+        // cleanup
+        GameObject.DestroyImmediate(playerObj);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(testObj);
+        controller = null;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/PatientTableTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class PatientTableTest
+{
+    private GameObject testObj;
+    private Furniture furniture;
+    private FurnitureController controller;
+
+    [SetUp]
+    public void Setup()
+    {
+        // patienttable mock
+        testObj = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/PatientTable"));
+        furniture = testObj.GetComponent<Furniture>();
+        controller = new PatientTableController(testObj.transform);
+        controller.isTriggerd = true;
+        furniture.Controller = controller;
+    }
+
+    [Test]
+    public void TestObjectIsNotNull_Test()
+    {
+        Assert.IsNotNull(testObj);
+    }
+
+    [Test]
+    public void FurnitrueIsNotNull_Test()
+    {
+        Assert.IsNotNull(furniture);
+    }
+
+    [Test]
+    public void ControllerIsNotNull_Test()
+    {
+        Assert.IsNotNull(controller);
+    }
+
+    [Test]
+    [TestCase(true, false)]
+    public void ArrowUpMovesTableUpWhenTableIsTriggerd_Test(bool up, bool down)
+    {
+        // setup
+        Vector3 before = testObj.transform.position;
+
+        // perform
+        controller.Interact(new bool[] { up, down }, 1f);
+
+        // get
+        Vector3 after = testObj.transform.position;
+
+        // assert
+        Assert.Greater(after.y, before.y);
+    }
+
+    [Test]
+    [TestCase(false, true)]
+    public void ArrowDownMovesTableDownWhenTableIsTriggerd_Test(bool up, bool down)
+    {
+        // setup
+        Vector3 before = testObj.transform.position;
+
+        // perform
+        controller.Interact(new bool[] { up, down }, 1f);
+
+        // get
+        Vector3 after = testObj.transform.position;
+
+        // assert
+        Assert.Less(after.y, before.y);
+    }
+
+    [Test]
+    [TestCase(true, true)]
+    public void ArrowUpAndArrowDownArePressedMovesTableUpWhenTableIsTriggerd_Test(bool up, bool down)
+    {
+        // setup
+        Vector3 before = testObj.transform.position;
+
+        // perform
+        controller.Interact(new bool[] { up, down }, 1f);
+
+        // get
+        Vector3 after = testObj.transform.position;
+
+        // assert
+        Assert.Greater(after.y, before.y);
+    }
+
+    [Test]
+    [TestCase(new bool[] { false, false, false })]
+    [TestCase(new bool[] { true, true, true, true, true })]
+    public void TheTableDontMoveWhenThereAreTooManyInstructions_Test(bool[] instructions)
+    {
+        // setup
+        Vector3 before = testObj.transform.position;
+
+        // perform
+        controller.Interact(instructions, 1f);
+
+        // get
+        Vector3 after = testObj.transform.position;
+
+        // assert
+        Assert.AreEqual(after.y, before.y);
+    }
+
+    [Test]
+    [TestCase(new bool[] { false })]
+    [TestCase(new bool[] { true })]
+    [TestCase(new bool[] { })]
+    public void TheTableDontMoveWhenThereAreNotEnoughInstructions_Test(bool[] instructions)
+    {
+        // setup
+        Vector3 before = testObj.transform.position;
+
+        // perform
+        controller.Interact(instructions, 1f);
+
+        // get
+        Vector3 after = testObj.transform.position;
+
+        // assert
+        Assert.AreEqual(after.y, before.y);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(testObj);
+        controller = null;
+    }
+}

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Furniture/ProtectionWallTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class ProtectionWallTest
+{
+    private GameObject testObj;
+    private Furniture furniture;
+    private FurnitureController controller;
+
+    [SetUp]
+    public void Setup()
+    {
+        // protection wall mock
+        GameObject prefab = Resources.Load<GameObject>("Prefabs/ProtectionWall");
+        testObj = GameObject.Instantiate(prefab);
+        testObj.name = "ProtectionWall";
+
+        furniture = testObj.GetComponent<Furniture>();
+        controller = new MoveableController(testObj.transform);
+    }
+
+    [Test]
+    public void FirstPressFWillLockTheWallToThePlayerMovementWhenIsTriggered_Test()
+    {
+        // setup
+        // player mock
+        GameObject playerObj = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Player_Mock"));
+        playerObj.name = "Player";
+
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // assert
+        Assert.IsNotNull(playerObj.transform.Find("ProtectionWall"));
+
+        // cleanup
+        GameObject.DestroyImmediate(playerObj);
+    }
+
+    [Test]
+    public void SecondPressFWillReleaseTheWallFromThePlayerMovementWhenIsTriggerd_Test()
+    {
+        // setup
+        // player mock
+        GameObject playerObj = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Player_Mock"));
+        playerObj.name = "Player";
+
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // assert
+        Assert.IsNotNull(playerObj.transform.Find("ProtectionWall"));
+
+        // perform
+        controller.Interact(new bool[] { true }, 1f);
+
+        // assert
+        Assert.IsNull(playerObj.transform.Find("ProtectionWall"));
+        Assert.IsNotNull(GameObject.Find("ProtectionWall"));
+
+        // cleanup
+        GameObject.DestroyImmediate(playerObj);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        GameObject.DestroyImmediate(testObj);
+        controller = null;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/InputWrapper/InputWrapperTest.cs

+using System;
+using NSubstitute;
+using NUnit.Framework;
+using UnityEngine;
+
+public class InputWrapperTest
+{
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void GetKeyReturnsExpectedValue_Test(bool expected)
+    {
+        // setup
+        IInputWrapper input = Substitute.For<IInputWrapper>();
+        input.GetKey(KeyCode.None).Returns(expected);
+
+        // perform
+        bool actual = input.GetKey(KeyCode.None);
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(true, KeyCode.A)]
+    [TestCase(false, KeyCode.A)]
+    [TestCase(true, KeyCode.Space)]
+    [TestCase(false, KeyCode.Space)]
+    public void GetKeyReturnsExpectedForKey_Test(bool expected, KeyCode code)
+    {
+        // setup
+        IInputWrapper input = Substitute.For<IInputWrapper>();
+        input.GetKey(code).Returns(expected);
+
+        // perform
+        bool actual = input.GetKey(code);
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void GetKeyDownReturnsExpectedValue_Test(bool expected)
+    {
+        // setup
+        IInputWrapper input = Substitute.For<IInputWrapper>();
+        input.GetKey(KeyCode.None).Returns(expected);
+
+        // perform
+        bool actual = input.GetKey(KeyCode.None);
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(true, KeyCode.A)]
+    [TestCase(false, KeyCode.A)]
+    [TestCase(true, KeyCode.Space)]
+    [TestCase(false, KeyCode.Space)]
+    public void GetKeyDownReturnsExpectedForKey_Test(bool expected, KeyCode code)
+    {
+        // setup
+        IInputWrapper input = Substitute.For<IInputWrapper>();
+        input.GetKey(code).Returns(expected);
+
+        // perform
+        bool actual = input.GetKey(code);
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(0f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void GetAxisReturnsExpectedValue_Test(float expected)
+    {
+        // setup
+        IInputWrapper input = Substitute.For<IInputWrapper>();
+        input.GetAxis("Mouse X").Returns(expected);
+
+        // perform
+        float actual = input.GetAxis("Mouse X");
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    [TestCase(0f, "Mouse X")]
+    [TestCase(1f, "Mouse X")]
+    [TestCase(0.5f, "Mouse Y")]
+    [TestCase(-1f, "Mouse Y")]
+    [TestCase(-0.5f, "Mouse X")]
+    public void GetAxisReturnsExpectedValue_Test(float expected, string axis)
+    {
+        // setup
+        IInputWrapper input = Substitute.For<IInputWrapper>();
+        input.GetAxis(axis).Returns(expected);
+
+        // perform
+        float actual = input.GetAxis(axis);
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Movement/MoveControllerTest.cs

+using System;
+using UnityEngine;
+using NUnit.Framework;
+
+public class MoveControllerTest
+{
+    private Transform mock;
+    private MoveController controller;
+
+    [SetUp]
+    public void SetUp()
+    {
+        // Mock gameobject
+        mock = GameObject.Instantiate(new GameObject()).transform;
+        mock.position = Vector3.zero;
+        mock.rotation = Quaternion.identity;
+        mock.gameObject.AddComponent<CharacterController>();
+      
+        // MoveController
+        controller = new MoveController(mock);
+    }
+
+    /// <summary>
+    /// Enables to get the value of a private field with given name.
+    /// Returns the value of the field.
+    /// </summary>
+    private T GetPrivateField<T>(string fieldName)
+    {
+        System.Reflection.FieldInfo info = controller.GetType().GetField(fieldName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        return (T)info.GetValue(controller);
+    }
+
+    [Test]
+    public void PlayerMovementIsExistent_Test()
+    {
+        // setup
+        GameObject go = GameObject.Instantiate(new GameObject());
+        PlayerMovement dm = go.AddComponent<PlayerMovement>();
+
+        // assert
+        Assert.IsNotNull(dm);
+    }
+
+    [Test]
+    public void PlayerTransformIsNotNull_Test()
+    {
+        Transform transform = GetPrivateField<Transform>("playerTransform");
+
+        Assert.IsNotNull(transform);
+    }
+
+    [Test]
+    public void CharacterControllerIsNotNull_Test()
+    {
+        CharacterController characterController = GetPrivateField<CharacterController>("characterController");
+
+        Assert.IsNotNull(characterController);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MovesAlongPositiveZforInputUP_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(0f, value, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.Greater(after.z, before.z);
+        Assert.AreEqual(before.x, after.x, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(0f)]
+    public void MovesNotForInputUPisZero_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(0f, value, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.AreEqual(after.z, before.z);
+        Assert.AreEqual(before.x, after.x, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MovesAlongNegativeZforInputDOWN_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(0f, value, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.Less(after.z, before.z);
+        Assert.AreEqual(before.x, after.x, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(0)]
+    public void MovesNotforInputDOWNisZero_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(0f, value, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.AreEqual(after.z, before.z);
+        Assert.AreEqual(before.x, after.x, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(0.1f)]
+    [TestCase(0.75639f)]
+    [TestCase(1f)]
+    [TestCase(0.5f)]
+    public void MovesAlongPositiveXforInputRIGHT_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(value, 0f, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.Greater(after.x, before.x);
+        Assert.AreEqual(before.z, after.z, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(0)]
+    public void MovesNotforInputRIGHTisZero_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(value, 0f, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.AreEqual(after.x, before.x);
+        Assert.AreEqual(before.z, after.z, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(-0.1f)]
+    [TestCase(-0.75639f)]
+    [TestCase(-1f)]
+    [TestCase(-0.5f)]
+    public void MovesAlongNegativeXforInputLEFT_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(value, 0f, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.Less(after.x, before.x);
+        Assert.AreEqual(before.z, after.z, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [Test]
+    [TestCase(0)]
+    public void MovesNotforInputLEFTisZero_Test(float value)
+    {
+        // setup
+        Vector3 before = mock.position;
+
+        // perform
+        controller.Move(value, 0f, 1f);
+
+        // get
+        Vector3 after = mock.position;
+
+        // assert
+        Assert.AreEqual(after.x, before.x);
+        Assert.AreEqual(before.z, after.z, 0.01f);
+        Assert.AreEqual(before.y, after.y, 0.01f);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(mock.gameObject);
+        controller = null;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/RayTracing/MeshContainerTest.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using NUnit.Framework;
+using System.Reflection;
+
+public class MeshContainerTest
+{
+    private MeshContainer container;
+    private GameObject meshObj;
+
+    // Can't be [SetUp] because these Functions can't have a parameter.
+    private void SetUp(string prefabName)
+    {
+        // create a mock gameobject with a mesh
+        GameObject docMeshPref = Resources.Load<GameObject>(prefabName);
+        meshObj = GameObject.Instantiate(docMeshPref);
+        container = new MeshContainer(meshObj.transform);
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple")]
+    [TestCase("Prefabs/Mock_complex")]
+    public void MeshContainerExists_Test(string mockName)
+    {
+        SetUp(mockName);
+        Assert.IsNotNull(container);
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple")]
+    [TestCase("Prefabs/Mock_complex")]
+    public void GameObjectHasMeshFilterComponent_Test(string mockName)
+    {
+        SetUp(mockName);
+        Assert.IsNotNull(meshObj.GetComponent<MeshFilter>());
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple")]
+    [TestCase("Prefabs/Mock_complex")]
+    public void MeshTransformIsNotNull_Test(string mockName)
+    {
+        SetUp(mockName);
+
+        // get
+        FieldInfo info = container.GetType().GetField("meshTransform", BindingFlags.NonPublic | BindingFlags.Instance);
+        Transform transform = (Transform) info.GetValue(container);
+
+        // assert
+        Assert.IsNotNull(transform);
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple")]
+    [TestCase("Prefabs/Mock_complex")]
+    public void GetVerticesReturnsNotNull_Test(string mockName)
+    {
+        SetUp(mockName);
+
+        Assert.IsNotNull(container.GetVertices());
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 24)]
+    [TestCase("Prefabs/Mock_complex", 54)]
+    public void GetVerticesReturnsCorrectNumberOfVertices_Test(string mockName, int expected)
+    {
+        SetUp(mockName);
+
+        // perform
+        Vector3[] vertices = container.GetVertices();
+
+        // assert
+        Assert.AreEqual(expected, vertices.Length);
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple")]
+    [TestCase("Prefabs/Mock_complex")]
+    public void GetNormalsReturnsNotNull_Test(string mockName)
+    {
+        SetUp(mockName);
+
+        Assert.IsNotNull(container.GetNormals());
+    }
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 24)]
+    [TestCase("Prefabs/Mock_complex", 54)]
+    public void GetNormalsReturnsCorrectNumberOfNormals_Test(string mockName, int expected)
+    {
+        SetUp(mockName);
+        
+        // perform
+        Vector3[] normals = container.GetNormals();
+
+        // assert
+        Assert.AreEqual(expected, normals.Length);
+    }
+
+    private Vector3[] normals = new Vector3[]
+    {
+        new Vector3(0f, 1f, 0f),
+        new Vector3(0f, 0f, -1f),
+        new Vector3(0f, 0f, -1f),
+        new Vector3(0f, 0f, 1f),
+        new Vector3(-1f, 0f, 0f),
+        new Vector3(1f, 0f, 0f),
+    };
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 0)]
+    [TestCase("Prefabs/Mock_simple", 4)]
+    [TestCase("Prefabs/Mock_simple", 8)]
+    [TestCase("Prefabs/Mock_simple", 12)]
+    [TestCase("Prefabs/Mock_simple", 16)]
+    [TestCase("Prefabs/Mock_simple", 20)]
+    public void GetNormalsReturnsCorrectNormals_Test(string mockName, int index)
+    {
+        // setup
+        SetUp(mockName);
+        Vector3 expected = normals[index / 4];
+        
+        // perform
+        Vector3 normal = container.GetNormals()[index];
+
+        // assert
+        Assert.AreEqual(expected.x, normal.x, delta: 0.001f);
+        Assert.AreEqual(expected.y, normal.y, delta: 0.001f);
+        Assert.AreEqual(expected.z, normal.z, delta: 0.001f);
+    }
+
+    private Vector3[] rotatedNormals = new Vector3[]
+    {
+        new Vector3(-0.0087f, 0.4999f, 0.8660f),
+        new Vector3(-0.7261f, 0.5922f, -0.3492f),
+        new Vector3(-0.7261f, 0.5922f, -0.3492f),
+        new Vector3(0.7261f, -0.5922f, 0.3492f),
+        new Vector3(-0.6875f, -0.6319f, 0.3578f),
+        new Vector3(0.6875f, 0.6319f, -0.3578f),
+    };
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 0)]
+    [TestCase("Prefabs/Mock_simple", 4)]
+    [TestCase("Prefabs/Mock_simple", 8)]
+    [TestCase("Prefabs/Mock_simple", 12)]
+    [TestCase("Prefabs/Mock_simple", 16)]
+    [TestCase("Prefabs/Mock_simple", 20)]
+    public void GetNormalsReturnsCorrectNormalsAfterRotation_Test(string mockName, int index)
+    {
+        // setup
+        SetUp(mockName);
+        meshObj.transform.Rotate(new Vector3(60f, -1f, 45.7f));
+        Vector3 expected = rotatedNormals[index / 4];
+
+        // perform
+        Vector3 normal = container.GetNormals()[index];
+
+        // assert
+        Assert.AreEqual(expected.x, normal.x, delta: 0.001f);
+        Assert.AreEqual(expected.y, normal.y, delta: 0.001f);
+        Assert.AreEqual(expected.z, normal.z, delta: 0.001f);
+    }
+
+    private Vector3[] vertices = new Vector3[]
+    {
+        new Vector3(0.5f, 0.5f, 0.5f),
+        new Vector3(-0.5f, 0.5f, 0.5f),
+        new Vector3(0.5f, 0.5f, -0.5f),
+        new Vector3(-0.5f, 0.5f, -0.5f),
+        new Vector3(0.5f, -0.5f, -0.5f),
+        new Vector3(-0.5f, -0.5f, -0.5f),
+        new Vector3(0.5f, -0.5f, 0.5f),
+        new Vector3(-0.5f, -0.5f, 0.5f),
+    };
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 0)]
+    [TestCase("Prefabs/Mock_simple", 1)]
+    [TestCase("Prefabs/Mock_simple", 2)]
+    [TestCase("Prefabs/Mock_simple", 3)]
+    [TestCase("Prefabs/Mock_simple", 4)]
+    [TestCase("Prefabs/Mock_simple", 5)]
+    [TestCase("Prefabs/Mock_simple", 6)]
+    [TestCase("Prefabs/Mock_simple", 7)]
+    public void GetVerticesRetrunsCorrectVertices_Test(string mockName, int index)
+    {
+        // setup
+        SetUp(mockName);
+        Vector3 expected = vertices[index];
+
+        // perform
+        Vector3 vertex = container.GetVertices()[index];
+
+        // assert
+        Assert.AreEqual(expected.x, vertex.x, delta: 0.001f);
+        Assert.AreEqual(expected.y, vertex.y, delta: 0.001f);
+        Assert.AreEqual(expected.z, vertex.z, delta: 0.001f);
+    }
+
+    
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 0)]
+    [TestCase("Prefabs/Mock_simple", 1)]
+    [TestCase("Prefabs/Mock_simple", 2)]
+    [TestCase("Prefabs/Mock_simple", 3)]
+    [TestCase("Prefabs/Mock_simple", 4)]
+    [TestCase("Prefabs/Mock_simple", 5)]
+    [TestCase("Prefabs/Mock_simple", 6)]
+    [TestCase("Prefabs/Mock_simple", 7)]
+    public void GetVerticesRetrunsCorrectVerticesAfterTranslation_Test(string mockName, int index)
+    {
+        // Array of expected vertice positions after translation.
+        Vector3[] translatedVertices = new Vector3[]
+        {
+            new Vector3(1.5f, 2.5f, 3.5f),
+            new Vector3(0.5f, 2.5f, 3.5f),
+            new Vector3(1.5f, 2.5f, 2.5f),
+            new Vector3(0.5f, 2.5f, 2.5f),
+            new Vector3(1.5f, 1.5f, 2.5f),
+            new Vector3(0.5f, 1.5f, 2.5f),
+            new Vector3(1.5f, 1.5f, 3.5f),
+            new Vector3(0.5f, 1.5f, 3.5f),
+        };
+
+        // setup
+        SetUp(mockName);
+        Vector3 expected = translatedVertices[index];
+
+        // perform
+        meshObj.transform.position = new Vector3(1f, 2f, 3f);
+        Vector3 vertex = container.GetVertices()[index];
+
+        // assert
+        Assert.AreEqual(expected.x, vertex.x, delta: 0.001f);
+        Assert.AreEqual(expected.y, vertex.y, delta: 0.001f);
+        Assert.AreEqual(expected.z, vertex.z, delta: 0.001f);
+    }
+
+    
+
+    [Test]
+    [TestCase("Prefabs/Mock_simple", 0)]
+    [TestCase("Prefabs/Mock_simple", 1)]
+    [TestCase("Prefabs/Mock_simple", 2)]
+    [TestCase("Prefabs/Mock_simple", 3)]
+    [TestCase("Prefabs/Mock_simple", 4)]
+    [TestCase("Prefabs/Mock_simple", 5)]
+    [TestCase("Prefabs/Mock_simple", 6)]
+    [TestCase("Prefabs/Mock_simple", 7)]
+    public void GetVerticesRetrunsCorrectVerticesAfterRotation_Test(string mockName, int index)
+    {
+        // Array of expected vertice positions after a rotation.
+        Vector3[] rotatedVertices = new Vector3[]
+        {
+            new Vector3(0.7024f, 0.2697f, 0.4287f),
+            new Vector3(0.0149f, -0.3621f, 0.7865f),
+            new Vector3(-0.0237f, 0.8620f, 0.0794f),
+            new Vector3(-0.7112f, 0.2301f, 0.4373f),
+            new Vector3(-0.0149f, 0.3621f, -0.7865f),
+            new Vector3(-0.7024f, -0.2697f, -0.4287f),
+            new Vector3(0.7112f, -0.2301f, -0.4373f),
+            new Vector3(0.0237f, -0.8620f, -0.0794f),
+        };
+
+        // setup
+        SetUp(mockName);
+        Vector3 expected = rotatedVertices[index];
+
+        // perform
+        meshObj.transform.Rotate(new Vector3(60f, -1f, 45.7f));
+        Vector3 vertex = container.GetVertices()[index];
+
+        // assert
+        Assert.AreEqual(expected.x, vertex.x, delta: 0.001f);
+        Assert.AreEqual(expected.y, vertex.y, delta: 0.001f);
+        Assert.AreEqual(expected.z, vertex.z, delta: 0.001f);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(meshObj);
+    }
+}

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/RayTracing/RayTracerTest.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using NUnit.Framework;
+
+public class RayTracerTest
+{
+    private RayTracer tracer;
+    private Transform source;
+
+    private readonly Vector3 MOCK_PLACE = Vector3.right * 3f;
+
+    [SetUp]
+    public void Setup()
+    {
+        // create a mock gameobject
+        GameObject gameObj = new GameObject("Source");
+        source = GameObject.Instantiate(gameObj).transform;
+
+        // create raytracer instance for the mock
+        tracer = new RayTracer(source.transform);
+    }
+
+    [Test]
+    public void RayTracerIsNotNull_Test()
+    {
+        Assert.IsNotNull(tracer);
+    }
+
+    [Test]
+    public void GetDistances_Test()
+    {
+        // setup positions
+        Vector3[] positions = new Vector3[]
+        {
+            new Vector3(0f, 0f, 0f),
+            new Vector3(1f, 0f, 0f),
+            new Vector3(0f, 1f, 0f),
+            new Vector3(0f, 0f, 1f),
+            new Vector3(-1f, 0f, 0f),
+            new Vector3(0f, -1f, 0f),
+            new Vector3(0f, 0f, -1f),
+            new Vector3(0f, 2f, 0f),
+            new Vector3(1f, 1f, 1f),
+            new Vector3(0f, 0f, 100f)
+        };
+
+        // setup expected distances
+        float[] expected = new float[]
+        {
+            0f, 1f, 1f, 1f, 1f, 1f, 1f, 2f, 1.732f, 100f
+        };
+
+        // perform
+        float[] distances = tracer.GetDistances(positions);
+
+        // assert
+        Assert.AreEqual(expected, distances);
+    }
+
+    [Test]
+    public void CreateRayReturnsFalseWhenNoHitDetected_Test()
+    {
+        // perform
+        bool hitted = tracer.CreateRay(MOCK_PLACE);
+
+        // assert
+        Assert.IsFalse(hitted);
+    }
+
+    [Test]
+    [TestCase("Mock_simple")]
+    [TestCase("Mock_complex")]
+    public void CreateRayReturnsTrueIfDocHitDetected_Test(string mockName)
+    {
+        // setup
+        GameObject mock = CreateMock(mockName, "Doc");
+
+        // perform
+        bool hitted = tracer.CreateRay(MOCK_PLACE);
+
+        // assert
+        Assert.IsTrue(hitted);
+
+        // clear
+        GameObject.DestroyImmediate(mock);
+    }
+
+    [Test]
+    [TestCase("Mock_simple")]
+    [TestCase("Mock_complex")]
+    public void CreateRayReturnsFalseIfOtherHitDetected_Test(string mockName)
+    {
+        // setup
+        GameObject mock = CreateMock(mockName, "Other");
+
+        // perform
+        bool hitted = tracer.CreateRay(MOCK_PLACE);
+
+        // assert
+        Assert.IsFalse(hitted);
+
+        // clear
+        GameObject.DestroyImmediate(mock);
+    }
+
+    [TearDown]
+    public void Teardown()
+    {
+        // remove references for clean next test
+        GameObject.DestroyImmediate(source.gameObject);
+        tracer = null;
+    }
+
+    /// <summary>
+    /// Creates a mock gameobject from a prefab named like "prefabName".
+    /// Sets the tag and name of the gameobject to the given "tag".
+    /// Returns the mock.
+    /// </summary>
+    private GameObject CreateMock(string prefabName, string tag)
+    {
+        GameObject prefab = Resources.Load<GameObject>("Prefabs/" + prefabName);
+        GameObject mock = GameObject.Instantiate(prefab, MOCK_PLACE, Quaternion.identity);
+        mock.name = tag;
+        mock.tag = tag;
+
+        return mock;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/RayTracing/VertexDataTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class VertexDataTest
+{
+    private VertexData data;
+
+    [SetUp]
+    public void SetUp()
+    {
+        data = new VertexData(new Vector3(), 0f);
+    }
+
+    [Test]
+    public void EmptyConstructor_Test()
+    {
+        data = new VertexData();
+
+        Assert.IsNotNull(data);
+    }
+
+    [Test]
+    public void Constructor_Test()
+    {
+        Assert.IsNotNull(data);
+    }
+
+    [Test]
+    public void ConstructorPosition_Test()
+    {
+        Assert.IsNotNull(data.Position);
+    }
+
+    [Test]
+    public void ConstructorDose_Test()
+    {
+        Assert.IsNotNull(data.Dose);
+    }
+
+    [Test]
+    public void ConstructorVerticeWithSamePos_Test()
+    {
+        Assert.IsNotNull(data.VerticeWithSamePos);
+    }
+
+    [Test]
+    public void PositionIsCorrect_Test()
+    {
+        // setup
+        Vector3 expected = new Vector3(1f, 2f, 3f);
+
+        // perform
+        data = new VertexData(expected, 0f);
+
+        // assert
+        Assert.AreEqual(expected, data.Position);
+    }
+
+    [Test]
+    public void DoseIsCorrect_Test()
+    {
+        // setup
+        float expected = 5.1f;
+
+        // perform
+        data = new VertexData(new Vector3(), expected);
+
+        // assert
+        Assert.AreEqual(expected, data.Dose);
+    }
+
+    [Test]
+    public void IsDirtyCorrect_Test()
+    {
+        Assert.IsFalse(data.isDirty);
+    }
+
+    [Test]
+    public void VerticeWithSamePosIsCorrect_Test()
+    {
+        Assert.AreEqual(0, data.VerticeWithSamePos.Length);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Utilities/ColorCalculatorTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public class ColorCalculatorTest
+{
+    [Test]
+    [TestCase(new float[] { }, new float[] { }, new float[] { }, new float[] { })]
+    [TestCase(new float[] { 0f, 10f, 200f }, new float[] { 1f, 0f, 1f}, new float[] { 1f, 1f, 0f }, new float[] { 0f, 0f, 0f })]
+    [TestCase(new float[] { 0f, -10f, -200f }, new float[] { 1f, 0f, 1f }, new float[] { 1f, 1f, 0f }, new float[] { 0f, 0f, 0f })]
+    public void CalculateReturnsExpectedColors_Test(float[] doses, float[] r, float[] g, float [] b)
+    {
+        // setup
+        Color32[] rgbColors = GetColors(r, g, b);
+
+        // perform
+        Color32[] colors = ColorCalculator.Calculate(doses);
+
+        // assert
+        Assert.AreEqual(rgbColors, colors);
+    }
+
+    /// <summary>
+    /// Builds Color32 objects form the given RGB values.
+    /// Necessary because testcases can't have non-constant parameters.
+    /// </summary>
+    private Color32[] GetColors(float[] r, float[] g, float[] b)
+    {
+        Color32[] rgbColors = new Color32[r.Length];
+
+        for (int i = 0; i < r.Length; i++)
+        {
+            rgbColors[i] = new Color(r[i], g[i], b[i]);
+        }
+
+        return rgbColors;
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Utilities/DoseCalculatorTest.cs

+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+using UnityEngine;
+
+public class DoseCalculatorTest
+{
+    [Test]
+    [TestCase(new float[] { }, new float[] { })]
+    [TestCase(new float[] { 1, 2f, 2.1f, 0f, 150f, float.NaN, -1f, -150f}, new float[] { 1.333f, 0.333f, 0.302f, float.PositiveInfinity, 0f, 0f, 1.333f, 0f})]
+    public void CalculateReturnsCorrectDoses_Test(float[] distances, float[] expected)
+    {
+        // perform
+        float[] doses = DoseCalculator.Calculate(distances, 100f, 1f);
+
+        // for easy readable numbers and corrections
+        for (int i = 0; i < doses.Length; i++)
+        {
+            doses[i] = (float)Math.Round(doses[i], 3);
+        }
+
+        // assert
+        Assert.AreEqual(expected, doses);
+    }
+
+    [Test]
+    [TestCase(new float[] { 1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, 10f}, 5.5f)]
+    [TestCase(new float[] { 1f, 2f, 1f, 1f, 1.5f, 2f}, 1.417f)]
+    public void GetAVGDoseReturnsCorrectDose_Test(float[] doses, float expected)
+    {
+        // perform
+        float actual = DoseCalculator.GetAVGDose(doses);
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Editor/Tests/Utilities/HSVColorTest.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using NUnit.Framework;
+
+public class HSVColorTest
+{
+    [Test]
+    public void HSVConstructorWithRGBColor_Test()
+    {
+        // setup
+        float r = 1f;
+        float g = 0.4f;
+        float b = 0.2f;
+        Color rgbColor = new Color(r, g, b);
+
+        HSVColor hsvColor = new HSVColor(rgbColor);
+
+        float h = 1f;
+        float s = 1f;
+        float v = 1f;
+
+        // perform
+        Color.RGBToHSV(rgbColor, out h, out s, out v);
+
+        // assert
+        Assert.AreEqual(h, hsvColor.h);
+        Assert.AreEqual(s, hsvColor.s);
+        Assert.AreEqual(v, hsvColor.v);
+    }
+
+    [Test]
+    [TestCase(0f)]
+    [TestCase(0.1f)]
+    [TestCase(0.5f)]
+    [TestCase(0.9f)]
+    //No need to test other values, because Unity's h values are only defined from [0, 1)
+    public void GetNew_Test(float value)
+    {
+        // setup
+        float expected = value;
+        HSVColor hsvColor = new HSVColor(Color.blue);
+
+        // perform
+        hsvColor = hsvColor.GetNew(value);
+
+        // assert
+        Assert.AreEqual(value, (float) Math.Round(hsvColor.h, 1));
+    }
+
+    private readonly Color[] colors = new Color[]
+    {
+        Color.red,
+        Color.blue,
+        Color.yellow,
+        Color.green
+    };
+
+    [Test]
+    public void ToRGB_Test()
+    {
+        // setup
+        Color expected = Color.white;
+        Color rgbColor = Color.black;
+
+        // perform
+        for (int i = 0; i < colors.Length; i++)
+        {
+            expected = colors[i];
+            rgbColor = new HSVColor(colors[i]).ToRGB();
+        }
+
+        // assert
+        Assert.AreEqual(expected, rgbColor);
+    }
+
+    [Test]
+    [TestCase(0f, 1f, 0f, 0f)]
+    [TestCase(1f, 1f, 0f, 0f)]
+    [TestCase(0.5f, 0f, 1f, 1f)]
+    [TestCase(0.25f, 0.5f, 1f, 0f)]
+    [TestCase(0.666666667f, 0f, 0f, 1f)]
+    [TestCase(0.333333334f, 0f, 1f, 0f)]
+    public void ToRGBAfterGetNew_Test(float h, float r, float g, float b)
+    {
+        // setup
+        Color expected = new Color(r, g, b);
+        HSVColor hsvColor = new HSVColor(Color.red);
+
+        // perform
+        hsvColor = hsvColor.GetNew(h);
+        Color actual = hsvColor.ToRGB();
+
+        // assert
+        Assert.AreEqual(expected, actual);
+    }
+}
\ No newline at end of file

XRaySimulation-master/XRaySimulation/Assets/Resources/Materials/Black_1.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Black_1
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.2924528, g: 0.28417584, b: 0.28417584, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

XRaySimulation-master/XRaySimulation/Assets/Resources/Textures/MeshView.renderTexture

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!84 &8400000
+RenderTexture:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: MeshView
+  m_ImageContentsHash:
+    serializedVersion: 2
+    Hash: 00000000000000000000000000000000
+  m_ForcedFallbackFormat: 4
+  m_DownscaleFallback: 0
+  serializedVersion: 3
+  m_Width: 256
+  m_Height: 256
+  m_AntiAliasing: 1
+  m_MipCount: -1
+  m_DepthFormat: 2
+  m_ColorFormat: 8
+  m_MipMap: 0
+  m_GenerateMips: 1
+  m_SRGB: 0
+  m_UseDynamicScale: 0
+  m_BindMS: 0
+  m_EnableCompatibleFormat: 1
+  m_TextureSettings:
+    serializedVersion: 2
+    m_FilterMode: 1
+    m_Aniso: 0
+    m_MipBias: 0
+    m_WrapU: 1
+    m_WrapV: 1
+    m_WrapW: 1
+  m_Dimension: 2
+  m_VolumeDepth: 1