Rider suggestions (#4778)

* more tests

* more suggestions

* more cleanup

* more imporvements

* fix compile error

Co-authored-by: Ruo-Ping Dong <ruoping.dong@unity3d.com>

Project/Assets/ML-Agents/Examples/3DBall/Scripts/Ball3DAgent.cs

-using System;
 using UnityEngine;
 using Unity.MLAgents;
 using Unity.MLAgents.Actuators;

Project/Assets/ML-Agents/Examples/Basic/Scripts/BasicController.cs

 using UnityEngine;
 using UnityEngine.SceneManagement;
 using Unity.MLAgents;
-using Unity.MLAgents.Actuators;
 using UnityEngine.Serialization;
 
 /// <summary>

Project/Assets/ML-Agents/Examples/Crawler/Scripts/CrawlerAgent.cs

-using System;
 using UnityEngine;
 using Unity.MLAgents;
 using Unity.Barracuda;
         Vector3 avgVel = Vector3.zero;
 
         //ALL RBS
-        int numOfRB = 0;
+        int numOfRb = 0;
-            numOfRB++;
+            numOfRb++;
-        avgVel = velSum / numOfRB;
+        avgVel = velSum / numOfRb;
         return avgVel;
     }
 

Project/Assets/ML-Agents/Examples/FoodCollector/Scripts/FoodCollectorAgent.cs

-using System;
 using UnityEngine;
 using Unity.MLAgents;
 using Unity.MLAgents.Actuators;
             dirToGo += transform.right * right;
             rotateDir = -transform.up * rotate;
 
-            var shootCommand = (int)discreteActions[0] > 0;
+            var shootCommand = discreteActions[0] > 0;
             if (shootCommand)
             {
                 m_Shoot = true;

Project/Assets/ML-Agents/Examples/Match3/Scripts/Match3Agent.cs

 
             m_TimeUntilMove = MoveTime;
 
-            var nextState = State.Invalid;
+            State nextState;
             switch (m_CurrentState)
             {
                 case State.FindMatches:
 
         bool HasValidMoves()
         {
-            foreach (var move in Board.ValidMoves())
+            foreach (var unused in Board.ValidMoves())
             {
                 return true;
             }

Project/Assets/ML-Agents/Examples/Match3/Scripts/Match3Drawer.cs

 using System.Collections.Generic;
 using UnityEngine;
-using Unity.MLAgents.Extensions.Match3;
 
 namespace Unity.MLAgentsExamples
 {

Project/Assets/ML-Agents/Examples/Match3/Scripts/Match3TileSelector.cs

-using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
         {
             AllTilesOff();
             emptyTile.SetActive(true);
-            return;
         }
         else
         {

Project/Assets/ML-Agents/Examples/Soccer/Scripts/AgentSoccer.cs

-using System;
 using UnityEngine;
 using Unity.MLAgents;
 using Unity.MLAgents.Actuators;

Project/Assets/ML-Agents/Examples/Template/Scripts/TemplateAgent.cs

-using UnityEngine;
 using Unity.MLAgents;
 using Unity.MLAgents.Actuators;
 using Unity.MLAgents.Sensors;

Project/Assets/ML-Agents/Examples/Walker/Scripts/WalkerAgent.cs

     const float m_maxWalkingSpeed = 10; //The max walking speed
 
     //Should the agent sample a new goal velocity each episode?
-    //If true, walkSpeed will be randomly set between zero and m_maxWalkingSpeed in OnEpisodeBegin() 
+    //If true, walkSpeed will be randomly set between zero and m_maxWalkingSpeed in OnEpisodeBegin()
     //If false, the goal velocity will be walkingSpeed
     public bool randomizeWalkSpeedEachEpisode;
 
         //ragdoll's avg vel
         var avgVel = GetAvgVelocity();
 
-        //current ragdoll velocity. normalized 
+        //current ragdoll velocity. normalized
         sensor.AddObservation(Vector3.Distance(velGoal, avgVel));
         //avg body vel relative to cube
         sensor.AddObservation(m_OrientationCube.transform.InverseTransformDirection(avgVel));
         Vector3 avgVel = Vector3.zero;
 
         //ALL RBS
-        int numOfRB = 0;
+        int numOfRb = 0;
-            numOfRB++;
+            numOfRb++;
-        avgVel = velSum / numOfRB;
+        avgVel = velSum / numOfRb;
         return avgVel;
     }
 

Project/Assets/ML-Agents/TestScenes/TestCompressedTexture/TestTextureSensor.cs

 using UnityEngine;
 using Unity.MLAgents.Sensors;
-using Unity.MLAgents;
 
 public class TestTextureSensor : ISensor
 {

Project/Assets/ML-Agents/TestScenes/TestCompressedTexture/TestTextureSensorComponent.cs

 using UnityEngine;
-using UnityEngine.Serialization;
 using Unity.MLAgents.Sensors;
 
 

com.unity.ml-agents.extensions/Editor/EditorExample.cs

-using Unity.MLAgents;
-
 namespace Unity.MLAgents.Extensions.Editor
 {
 

com.unity.ml-agents.extensions/Editor/RigidBodySensorComponentEditor.cs

-using UnityEngine;
 using UnityEditor;
 using Unity.MLAgents.Editor;
 using Unity.MLAgents.Extensions.Sensors;

com.unity.ml-agents.extensions/Runtime/Match3/Match3ActuatorComponent.cs

         /// </summary>
         [FormerlySerializedAs("ForceRandom")]
         [Tooltip("Force using the Agent's Heuristic() method to decide the action. This should only be used in testing.")]
-        public bool ForceHeuristic = false;
+        public bool ForceHeuristic;
 
         /// <inheritdoc/>
         public override IActuator CreateActuator()

com.unity.ml-agents.extensions/Runtime/Sensors/CountingGridSensor.cs

 using System;
 using UnityEngine;
-using UnityEngine.Assertions;
 
 namespace Unity.MLAgents.Extensions.Sensors
 {

com.unity.ml-agents.extensions/Runtime/Sensors/PhysicsBodySensor.cs

 using System.Collections.Generic;
+#if UNITY_2020_1_OR_NEWER
+#endif
 using Unity.MLAgents.Sensors;
 
 namespace Unity.MLAgents.Extensions.Sensors

com.unity.ml-agents.extensions/Runtime/Sensors/RigidBodyJointExtractor.cs

-using System.Collections.Generic;
 using UnityEngine;
 using Unity.MLAgents.Sensors;
 

com.unity.ml-agents.extensions/Tests/Editor/Match3/AbstractBoardTests.cs

         public override int GetCellType(int row, int col)
         {
             var character = m_Board[m_Board.Length - 1 - row][col];
-            return (int)(character - '0');
+            return (character - '0');
-            return (int)(character - '0');
+            return (character - '0');
         }
 
     }

com.unity.ml-agents.extensions/Tests/Editor/Match3/Match3SensorTests.cs

-using System;
-using Unity.MLAgents.Actuators;
 using Unity.MLAgents.Extensions.Match3;
 using UnityEngine;
 using Unity.MLAgents.Extensions.Tests.Sensors;

com.unity.ml-agents.extensions/Tests/Editor/Sensors/ChannelHotPerceiveTests.cs

         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1 };
-            dummyData.Data = new float[] { -0.1f };
+            dummyData.Data = new[] { -0.1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1 };
-            dummyData.Data = new float[] { 1.1f };
+            dummyData.Data = new[] { 1.1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1 };
-            dummyData.Data = new float[] { .2f };
+            dummyData.Data = new[] { .2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .2f }, 4);
-            float[] expectedDefault = new float[] { 0 };
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .2f }, 4);
+            float[] expectedDefault = new[] { 0.0f };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
 
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { -1f };
+            dummyData.Data = new[] { -1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { 4f };
+            dummyData.Data = new[] { 4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { 2f };
+            dummyData.Data = new[] { 2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
 
             Assert.AreEqual(10 * 10 * 3, output.Length);
 
-            int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
+            int[] subarrayIndicies = new[] { 77, 78, 87, 88 };
-            float[] expectedDefault = new float[] { 1, 0, 0 };
+            float[] expectedDefault = new[] { 1.0f, 0.0f, 0.0f };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
 
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { 2.4f };
+            dummyData.Data = new[] { 2.4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1, 1 };
-            dummyData.Data = new float[] { .4f, .3f };
+            dummyData.Data = new[] { .4f, .3f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 2, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .4f, .3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .4f, .3f }, 4);
             float[] expectedDefault = new float[] { 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1, 3 };
-            dummyData.Data = new float[] { .4f, 4f };
+            dummyData.Data = new[] { .4f, 4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1, 3 };
-            dummyData.Data = new float[] { .4f, 1f };
+            dummyData.Data = new[] { .4f, 1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 4, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .4f, 0, 1, 0 }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .4f, 0, 1, 0 }, 4);
             float[] expectedDefault = new float[] { 0, 1, 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3, 1 };
-            dummyData.Data = new float[] { 1f, .4f };
+            dummyData.Data = new[] { 1f, .4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
 
             Assert.AreEqual(10 * 10 * 4, output.Length);
 
-            int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 0, 1, 0, .4f }, 4);
+            int[] subarrayIndicies = new[] { 77, 78, 87, 88 };
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 0, 1, 0, .4f }, 4);
             float[] expectedDefault = new float[] { 1, 0, 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3, 3 };
-            dummyData.Data = new float[] { 1f, 2.2f };
+            dummyData.Data = new[] { 1f, 2.2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 5, 1, 3 };
-            dummyData.Data = new float[] { 3f, .6f, 2.2f };
+            dummyData.Data = new[] { 3f, .6f, 2.2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 9, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 0, 0, 0, 1, 0, .6f, 0, 0, 1 }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 0, 0, 0, 1, 0, .6f, 0, 0, 1 }, 4);
             float[] expectedDefault = new float[] { 1, 0, 0, 0, 0, 0, 1, 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 5, 1, 3 };
-            dummyData.Data = new float[] { 3f, .6f, 2.2f };
+            dummyData.Data = new[] { 3f, .6f, 2.2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.ChannelHot,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 9, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 0, 0, 0, 1, 0, .6f, 0, 0, 1 }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 0, 0, 0, 1, 0, .6f, 0, 0, 1 }, 4);
             float[] expectedDefault = new float[] { 1, 0, 0, 0, 0, 0, 1, 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
 

com.unity.ml-agents.extensions/Tests/Editor/Sensors/ChannelHotShapeTests.cs

 using NUnit.Framework;
 using UnityEngine;
 using Unity.MLAgents.Extensions.Sensors;
-using NUnit.Framework.Internal;
-using UnityEngine.TestTools;
-using System.Collections;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
 {

com.unity.ml-agents.extensions/Tests/Editor/Sensors/ChannelPerceiveTests.cs

 using UnityEngine.TestTools;
 using Unity.MLAgents.Extensions.Sensors;
 using Unity.MLAgents.Extensions.TestUtils.Sensors;
-using System.Linq;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
 {
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1 };
-            dummyData.Data = new float[] { -0.1f };
+            dummyData.Data = new[] { -0.1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1 };
-            dummyData.Data = new float[] { 1.1f };
+            dummyData.Data = new[] { 1.1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1 };
-            dummyData.Data = new float[] { .2f };
+            dummyData.Data = new[] { .2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .2f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .2f }, 4);
             float[] expectedDefault = new float[] { 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { -1f };
+            dummyData.Data = new[] { -1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { 4f };
+            dummyData.Data = new[] { 4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { 2f };
+            dummyData.Data = new[] { 2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 2f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 2f / 3f }, 4);
             float[] expectedDefault = new float[] { 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3 };
-            dummyData.Data = new float[] { 2.4f };
+            dummyData.Data = new[] { 2.4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 2.4f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 2.4f / 3f }, 4);
             float[] expectedDefault = new float[] { 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1, 1 };
-            dummyData.Data = new float[] { .4f, .3f };
+            dummyData.Data = new[] { .4f, .3f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 2, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .4f, .3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .4f, .3f }, 4);
             float[] expectedDefault = new float[] { 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1, 3 };
-            dummyData.Data = new float[] { .4f, 4f };
+            dummyData.Data = new[] { .4f, 4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 1, 3 };
-            dummyData.Data = new float[] { .4f, 1f };
+            dummyData.Data = new[] { .4f, 1f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 2, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .4f, 1f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .4f, 1f / 3f }, 4);
             float[] expectedDefault = new float[] { 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3, 1 };
-            dummyData.Data = new float[] { 1f, .4f };
+            dummyData.Data = new[] { 1f, .4f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 2, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 1f / 3f, .4f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 1f / 3f, .4f }, 4);
             float[] expectedDefault = new float[] { 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 3, 3 };
-            dummyData.Data = new float[] { 1f, 2.2f };
+            dummyData.Data = new[] { 1f, 2.2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 2, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 1f / 3f, 2.2f / 3 }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 1f / 3f, 2.2f / 3 }, 4);
             float[] expectedDefault = new float[] { 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 5, 1, 3 };
-            dummyData.Data = new float[] { 3f, .6f, 2.2f };
+            dummyData.Data = new[] { 3f, .6f, 2.2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 3, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 3f / 5f, .6f, 2.2f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 3f / 5f, .6f, 2.2f / 3f }, 4);
             float[] expectedDefault = new float[] { 0, 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
         {
             string[] tags = { k_Tag1 };
             int[] depths = { 5, 1, 3 };
-            dummyData.Data = new float[] { 3f, .6f, 2.2f };
+            dummyData.Data = new[] { 3f, .6f, 2.2f };
             Color[] colors = { Color.red, Color.magenta };
             gridSensor.SetParameters(tags, depths, GridSensor.GridDepthType.Channel,
                 1f, 1f, 10, 10, LayerMask.GetMask("Default"), false, colors);
             Assert.AreEqual(10 * 10 * 3, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 3f / 5f, .6f, 2.2f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 3f / 5f, .6f, 2.2f / 3f }, 4);
             float[] expectedDefault = new float[] { 0, 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
 

com.unity.ml-agents.extensions/Tests/Editor/Sensors/ChannelShapeTests.cs

 using NUnit.Framework;
 using UnityEngine;
 using Unity.MLAgents.Extensions.Sensors;
-using NUnit.Framework.Internal;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
 {

com.unity.ml-agents.extensions/Tests/Editor/Sensors/CountingGridSensorPerceiveTests.cs

             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 1f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 1f }, 4);
             float[] expectedDefault = new float[] { 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 1f }, 4);
-            float[] expectedDefault = new float[] { 0 };
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 1f }, 4);
+            float[] expectedDefault = new float[] { 0f };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
 
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .5f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .5f }, 4);
             float[] expectedDefault = new float[] { 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
             Assert.AreEqual(10 * 10 * 2, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { .5f, 1 }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { .5f, 1 }, 4);
             float[] expectedDefault = new float[] { 0, 0 };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }

com.unity.ml-agents.extensions/Tests/Editor/Sensors/CountingGridSensorShapeTests.cs

 using UnityEngine;
 using NUnit.Framework;
 using Unity.MLAgents.Extensions.Sensors;
-using NUnit.Framework.Internal;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
 {

com.unity.ml-agents.extensions/Tests/Editor/Sensors/GridObservationPerceiveTests.cs

 using UnityEngine;
 using UnityEngine.TestTools;
 using Unity.MLAgents.Extensions.Sensors;
-using System.Linq;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
 {
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 2f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 2f / 3f }, 4);
             float[] expectedDefault = new float[] { 0f };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }
             Assert.AreEqual(10 * 10 * 1, output.Length);
 
             int[] subarrayIndicies = new int[] { 77, 78, 87, 88 };
-            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new float[] { 1f / 3f }, 4);
+            float[][] expectedSubarrays = GridObsTestUtils.DuplicateArray(new[] { 1f / 3f }, 4);
             float[] expectedDefault = new float[] { 0f };
             GridObsTestUtils.AssertSubarraysAtIndex(output, subarrayIndicies, expectedSubarrays, expectedDefault);
         }

com.unity.ml-agents.extensions/Tests/Editor/Sensors/GridSensorTestUtils.cs

 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.Linq;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
         /// </summary>
         /// <param name="arr">The array to convert to string</param>
         /// <param name="initialIndex">The initial index. Default 0</param>
-        /// <param name="numOfElements">The number of elements to print</param>
+        /// <param name="maxNumberOfElements">The number of elements to print</param>
         /// <returns>Human readable string</returns>
         public static string Array2Str<T>(T[] arr, int initialIndex = 0, int maxNumberOfElements = int.MaxValue)
         {
         /// If the total array is data from a 4x4x2 grid observation, total will be an array of size 32 and each sub array will have a size of 2.
         /// Let 3 cells at indicies (0, 1), (2, 2), and (3, 0) with values ([.1, .5]), ([.9, .7]), ([0, .2]), respectively.
         /// If the default values of cells are ([0, 0]) then the grid observation will be as follows:
-        /// [ [0,  0], [.1, .5], [ 0, 0 ], [0, 0], 
+        /// [ [0,  0], [.1, .5], [ 0, 0 ], [0, 0],
-        ///   
+        ///
-        /// 
+        ///
         /// The indicies of the activated cells in the flattened array will be 1, 10, and 12
         ///
         /// So to verify that the total array is as expected, AssertSubarraysAtIndex should be called as

com.unity.ml-agents.extensions/Tests/Editor/Sensors/PoseExtractorTests.cs

         {
             Assert.Throws<UnityAgentsException>(() =>
             {
-                var bad = new BadPoseExtractor();
+                var unused = new BadPoseExtractor();
             });
         }
 

com.unity.ml-agents.extensions/Tests/Editor/Sensors/RigidBodyPoseExtractorTests.cs

 using UnityEngine;
 using NUnit.Framework;
 using Unity.MLAgents.Extensions.Sensors;
-using UnityEditor;
 
 namespace Unity.MLAgents.Extensions.Tests.Sensors
 {
             Assert.AreEqual(0, poseExtractor.NumPoses);
 
             // Add an RB under the other GameObject. Constructor will find a rigid body, but not the root.
-            var otherRb = otherGameObj.AddComponent<Rigidbody>();
+            otherGameObj.AddComponent<Rigidbody>();
             poseExtractor = new RigidBodyPoseExtractor(rootRb, otherGameObj);
             Assert.AreEqual(0, poseExtractor.NumPoses);
         }
             var rb1 = rootObj.AddComponent<Rigidbody>();
 
             var go2 = new GameObject();
-            var rb2 = go2.AddComponent<Rigidbody>();
+            go2.AddComponent<Rigidbody>();
             go2.transform.SetParent(rootObj.transform);
 
             var joint = go2.AddComponent<ConfigurableJoint>();

com.unity.ml-agents.extensions/Tests/Editor/Sensors/RigidBodySensorTests.cs

         public static void CompareObservation(ISensor sensor, float[] expected)
         {
             string errorMessage;
-            bool isOK = SensorHelper.CompareObservation(sensor, expected, out errorMessage);
-            Assert.IsTrue(isOK, errorMessage);
+            bool isOk = SensorHelper.CompareObservation(sensor, expected, out errorMessage);
+            Assert.IsTrue(isOk, errorMessage);
-            bool isOK = SensorHelper.CompareObservation(sensor, expected, out errorMessage);
-            Assert.IsTrue(isOK, errorMessage);
+            bool isOk = SensorHelper.CompareObservation(sensor, expected, out errorMessage);
+            Assert.IsTrue(isOk, errorMessage);
         }
     }
 

com.unity.ml-agents.extensions/Tests/Runtime/RuntimeExampleTest.cs

-using UnityEngine;
-using UnityEditor;
-using UnityEngine.TestTools;
-using System.Collections;
 
 namespace Unity.MLAgents.Extensions.Tests
 {

com.unity.ml-agents/Editor/BehaviorParametersEditor.cs

 using Unity.MLAgents.Policies;
 using Unity.MLAgents.Sensors;
 using Unity.MLAgents.Sensors.Reflection;
-using UnityEngine;
 
 namespace Unity.MLAgents.Editor
 {
             var so = serializedObject;
             so.Update();
             bool needPolicyUpdate; // Whether the name, model, inference device, or BehaviorType changed.
-            bool needBrainParametersUpdate; // Whether the brain parameters changed
 
             // Drawing the Behavior Parameters
             EditorGUI.indentLevel++;
                 EditorGUILayout.PropertyField(so.FindProperty(k_BrainParametersName), true);
             }
             EditorGUI.EndDisabledGroup();
-            needBrainParametersUpdate = EditorGUI.EndChangeCheck();
 
             EditorGUI.BeginChangeCheck();
             {

com.unity.ml-agents/Editor/CameraSensorComponentEditor.cs

-using UnityEngine;
 using UnityEditor;
 using Unity.MLAgents.Sensors;
 

com.unity.ml-agents/Editor/DemonstrationDrawer.cs

 using System.Text;
 using UnityEditor;
 using Unity.MLAgents.Demonstrations;
-using Unity.MLAgents.Policies;
 
 
 namespace Unity.MLAgents.Editor

com.unity.ml-agents/Editor/RenderTextureSensorComponentEditor.cs

-using UnityEngine;
 using UnityEditor;
 using Unity.MLAgents.Sensors;
 namespace Unity.MLAgents.Editor

com.unity.ml-agents/Runtime/Actuators/ActuatorDiscreteActionMask.cs

 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace Unity.MLAgents.Actuators
 {

com.unity.ml-agents/Runtime/Actuators/ActuatorManager.cs

         /// <summary>
         /// Iterates through all of the IActuators in this list and calls their
         /// <see cref="IActionReceiver.OnActionReceived"/> method on them with the appropriate
-        /// <see cref="ActionSegment{T}"/>s depending on their <see cref="IActionReceiver.ActionSpec"/>.
+        /// <see cref="ActionSegment{T}"/>s depending on their <see cref="ActionSpec"/>.
         /// </summary>
         public void ExecuteActions()
         {

com.unity.ml-agents/Runtime/Actuators/IActionReceiver.cs

         /// </summary>
         /// <param name="actionSpec"><see cref="ActionSpec"/> of the <see cref="ActionBuffers"/></param>
         /// <param name="actions">The float array of all actions, including discrete and continuous actions.</param>
-        /// <returns>An <see cref="ActionBuffers"/> instance initialized with a <see cref="ActionSpec"/> and a float array.
+        /// <returns>An <see cref="ActionBuffers"/> instance initialized with a <see cref="ActionSpec"/> and a float array.</returns>
         internal static ActionBuffers FromActionSpec(ActionSpec actionSpec, float[] actions)
         {
             if (actions == null)

com.unity.ml-agents/Runtime/Actuators/VectorActuator.cs

-using System;
-
-using Unity.MLAgents.Policies;
-
 namespace Unity.MLAgents.Actuators
 {
     /// <summary>

com.unity.ml-agents/Runtime/Analytics/InferenceAnalytics.cs

-using System;
 using System.Collections.Generic;
 using Unity.Barracuda;
 using Unity.MLAgents.Actuators;
         /// <summary>
         /// Whether or not we've registered this particular event yet
         /// </summary>
-        static bool s_EventRegistered = false;
+        static bool s_EventRegistered;
 
         /// <summary>
         /// Hourly limit for this event name

com.unity.ml-agents/Runtime/Communicator/GrpcExtensions.cs

         /// <summary>
         /// Convert a ActionSpec struct to a ActionSpecProto.
         /// </summary>
-        /// <param name="actionSpecProto">An instance of an action spec struct.</param>
+        /// <param name="actionSpec">An instance of an action spec struct.</param>
         /// <returns>An ActionSpecProto.</returns>
         public static ActionSpecProto ToActionSpecProto(this ActionSpec actionSpec)
         {

com.unity.ml-agents/Runtime/Communicator/ICommunicator.cs

 using System;
 using System.Collections.Generic;
 using Unity.MLAgents.Actuators;
-using Unity.MLAgents.Policies;
 using Unity.MLAgents.Sensors;
 
 namespace Unity.MLAgents

com.unity.ml-agents/Runtime/Communicator/RpcCommunicator.cs

 using Unity.MLAgents.Actuators;
 using Unity.MLAgents.CommunicatorObjects;
 using Unity.MLAgents.Sensors;
-using Unity.MLAgents.Policies;
 using Unity.MLAgents.SideChannels;
 using Google.Protobuf;
 

com.unity.ml-agents/Runtime/Demonstrations/DemonstrationMetaData.cs

 using System;
-using UnityEngine;
 using UnityEngine.Serialization;
 
 namespace Unity.MLAgents.Demonstrations

com.unity.ml-agents/Runtime/Demonstrations/DemonstrationRecorder.cs

         /// </summary>
         [Tooltip("Number of steps to record. The editor will stop playing when it reaches this threshold. " +
                  "Set to zero to record indefinitely.")]
-        public int NumStepsToRecord = 0;
+        public int NumStepsToRecord;
 
         /// <summary>
         /// Base demonstration file name. If multiple files are saved, the additional filenames

com.unity.ml-agents/Runtime/DiscreteActionMasker.cs

-using System;
 using System.Collections.Generic;
 using Unity.MLAgents.Actuators;
 

com.unity.ml-agents/Runtime/Inference/BarracudaModelExtensions.cs

         /// <param name="model">
         /// The Barracuda engine model for loading static parameters.
         /// </param>
+        /// <param name="failedModelChecks">Output list of failure messages</param>
+        ///
         /// <returns>True if the model contains all the expected tensors.</returns>
         public static bool CheckExpectedTensors(this Model model, List<string> failedModelChecks)
         {

com.unity.ml-agents/Runtime/Inference/BarracudaModelParamLoader.cs

         /// <param name="memory">
         /// The memory size that the model is expecting.
         /// </param>
-        /// <param name="isContinuous">
-        /// Whether the model is expecting continuous or discrete control.
-        /// </param>
-        /// <param name="observableAttributeTotalSize">Total size of ObservableAttributes</param>
         /// <returns>
         /// A IEnumerable of string corresponding to the failed input presence checks.
         /// </returns>
         /// The BrainParameters that are used verify the compatibility with the InferenceEngine
         /// </param>
         /// <param name="actuatorComponents">Array of attached actuator components.</param>
-        /// <param name="isContinuous">
-        /// Whether the model is expecting continuous or discrete control.
-        /// </param>
-        /// <param name="modelContinuousActionSize">
-        /// The size of the continuous action output that is expected by the model.
-        /// </param>
-        /// <param name="modelSumDiscreteBranchSizes">
-        /// The size of the discrete action output that is expected by the model.
-        /// </param>
         /// <returns>
         /// A IEnumerable of string corresponding to the incompatible shapes between model
         /// and BrainParameters.
         /// The BrainParameters that are used verify the compatibility with the InferenceEngine
         /// </param>
         /// <param name="actuatorComponents">Array of attached actuator components.</param>
-        /// <param name="shape"> The tensor shape that is expected by the model</param>
-        /// <param name="modelContinuousActionSize">
-        /// The size of the continuous action output that is expected by the model.
-        /// </param>
         /// <param name="modelSumDiscreteBranchSizes">
         /// The size of the discrete action output that is expected by the model.
         /// </param>
         /// The BrainParameters that are used verify the compatibility with the InferenceEngine
         /// </param>
         /// <param name="actuatorComponents">Array of attached actuator components.</param>
-        /// <param name="shape"> The tensor shape that is expected by the model</param>
-        /// </param>
-        /// <param name="modelSumDiscreteBranchSizes">
-        /// The size of the discrete action output that is expected by the model.
         /// </param>
         /// <returns>If the Check failed, returns a string containing information about why the
         /// check failed. If the check passed, returns null.</returns>

com.unity.ml-agents/Runtime/Inference/TensorApplier.cs

 using System.Collections.Generic;
 using Unity.Barracuda;
 using Unity.MLAgents.Actuators;
-using Unity.MLAgents.Policies;
 
 
 namespace Unity.MLAgents.Inference

com.unity.ml-agents/Runtime/Policies/BarracudaPolicy.cs

-using System;
 using Unity.Barracuda;
 using System.Collections.Generic;
 using Unity.MLAgents.Actuators;

com.unity.ml-agents/Runtime/Policies/RemotePolicy.cs

-using UnityEngine;
-using System;
 using Unity.MLAgents.Actuators;
 using Unity.MLAgents.Sensors;
 

com.unity.ml-agents/Runtime/Sampler.cs

 using System;
 using System.Collections.Generic;
 using Unity.MLAgents.Inference.Utils;
-using UnityEngine;
 using Random = System.Random;
 
 namespace Unity.MLAgents
             // Will be used to normalize intervalFuncs
             float sumIntervalSizes = 0;
             //The number of intervals
-            int numIntervals = (int)(intervals.Count / 2);
+            int numIntervals = (intervals.Count / 2);
             // List that will store interval lengths
             float[] intervalSizes = new float[numIntervals];
             // List that will store uniform distributions

com.unity.ml-agents/Runtime/SensorHelper.cs

-using UnityEngine;
 using Unity.Barracuda;
 
 namespace Unity.MLAgents.Sensors

com.unity.ml-agents/Runtime/Sensors/ObservationWriter.cs

             }
             else if (shape.Length == 2)
             {
-                m_TensorShape = new TensorShape(new int[] { m_Batch, 1, shape[0], shape[1] });
+                m_TensorShape = new TensorShape(new[] { m_Batch, 1, shape[0], shape[1] });
             }
             else
             {

com.unity.ml-agents/Runtime/Sensors/Reflection/EnumReflectionSensor.cs

 using System;
-using UnityEngine;
 
 namespace Unity.MLAgents.Sensors.Reflection
 {

com.unity.ml-agents/Runtime/Sensors/Reflection/IntReflectionSensor.cs

         internal override void WriteReflectedField(ObservationWriter writer)
         {
             var intVal = (System.Int32)GetReflectedValue();
-            writer[0] = (float)intVal;
+            writer[0] = intVal;
         }
     }
 }

com.unity.ml-agents/Runtime/Sensors/StackingSensor.cs

             {
                 if (wrappedNumChannel == 1)
                 {
-                    wrappedMapping = new int[] { 0, 0, 0 };
+                    wrappedMapping = new[] { 0, 0, 0 };
                 }
                 else
                 {

com.unity.ml-agents/Runtime/Utilities.cs

 using System;
-using UnityEngine;
-using Unity.MLAgents.Sensors;
 
 namespace Unity.MLAgents
 {

com.unity.ml-agents/Tests/Editor/Actuators/ActuatorDiscreteActionMaskTests.cs

-using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using Unity.MLAgents.Actuators;

com.unity.ml-agents/Tests/Editor/Actuators/ActuatorManagerTests.cs

 using System;
-using System.Collections.Generic;
-using System.Text.RegularExpressions;
-using Unity.MLAgents.Policies;
 using UnityEngine;
 using UnityEngine.TestTools;
 using Assert = UnityEngine.Assertions.Assert;

com.unity.ml-agents/Tests/Editor/Actuators/VectorActuatorTests.cs

 using System.Linq;
 using NUnit.Framework;
 using Unity.MLAgents.Actuators;
-using Unity.MLAgents.Policies;
 using Assert = UnityEngine.Assertions.Assert;
 
 namespace Unity.MLAgents.Tests.Actuators

com.unity.ml-agents/Tests/Editor/Communicator/GrpcExtensionsTests.cs

 using NUnit.Framework;
-using UnityEngine;
 using Unity.MLAgents.Policies;
 using Unity.MLAgents.Demonstrations;
 using Unity.MLAgents.Actuators;
             var sparseChannelSensor = new DummySparseChannelSensor();
             sparseChannelSensor.Mapping = null;
             Assert.AreEqual(GrpcExtensions.IsTrivialMapping(sparseChannelSensor), true);
-            sparseChannelSensor.Mapping = new int[] { 0, 0, 0 };
+            sparseChannelSensor.Mapping = new[] { 0, 0, 0 };
-            sparseChannelSensor.Mapping = new int[] { 0, 1, 2, 3, 4 };
+            sparseChannelSensor.Mapping = new[] { 0, 1, 2, 3, 4 };
-            sparseChannelSensor.Mapping = new int[] { 1, 2, 3, 4, -1, -1 };
+            sparseChannelSensor.Mapping = new[] { 1, 2, 3, 4, -1, -1 };
-            sparseChannelSensor.Mapping = new int[] { 0, 0, 0, 1, 1, 1 };
+            sparseChannelSensor.Mapping = new[] { 0, 0, 0, 1, 1, 1 };
             Assert.AreEqual(GrpcExtensions.IsTrivialMapping(sparseChannelSensor), false);
         }
     }

com.unity.ml-agents/Tests/Editor/Communicator/RpcCommunicatorTests.cs

-using System;
-using System.Text.RegularExpressions;
-using UnityEngine;
 using UnityEngine.TestTools;
 
 namespace Unity.MLAgents.Tests.Communicator

com.unity.ml-agents/Tests/Editor/DemonstrationTests.cs

                 done = true,
                 episodeId = 5,
                 maxStepReached = true,
-                storedActions = new ActionBuffers(null, new int[] { 0, 1 }),
+                storedActions = new ActionBuffers(null, new[] { 0, 1 }),
             };
 
 

com.unity.ml-agents/Tests/Editor/EditModeTestInternalBrainTensorApplier.cs

         [Test]
         public void ApplyHybridActionOutput()
         {
-            var actionSpec = new ActionSpec(3, new int[] { 2, 3 });
+            var actionSpec = new ActionSpec(3, new[] { 2, 3 });
             var continuousInputTensor = new TensorProxy()
             {
                 shape = new long[] { 2, 3 },

com.unity.ml-agents/Tests/Editor/ModelRunnerTest.cs

 
         ActionSpec GetHybrid0vis53vec_3c_2dActionSpec()
         {
-            return new ActionSpec(3, new int[] { 2 });
+            return new ActionSpec(3, new[] { 2 });
         }
 
         [SetUp]

com.unity.ml-agents/Tests/Editor/ParameterLoaderTest.cs

             var validBrainParameters = new BrainParameters();
             validBrainParameters.VectorObservationSize = 53;
             validBrainParameters.NumStackedVectorObservations = 1;
-            validBrainParameters.ActionSpec = new ActionSpec(3, new int[] { 2 });
+            validBrainParameters.ActionSpec = new ActionSpec(3, new[] { 2 });
             return validBrainParameters;
         }
 
             var model = ModelLoader.Load(hybridONNXModel);
 
             var brainParameters = GetHybridBrainParameters();
-            brainParameters.ActionSpec = new ActionSpec(3, new int[] { 3 }); ; // Invalid discrete action size
+            brainParameters.ActionSpec = new ActionSpec(3, new[] { 3 }); // Invalid discrete action size
             var errors = BarracudaModelParamLoader.CheckModel(model, brainParameters, new SensorComponent[] { sensor_21_20_3, sensor_20_22_3 }, new ActuatorComponent[0]);
             Assert.Greater(errors.Count(), 0);
 

com.unity.ml-agents/Tests/Editor/RecursionCheckerTests.cs

         class InfiniteRecurser
         {
             RecursionChecker m_checker = new RecursionChecker("InfiniteRecurser");
-            public int NumCalls = 0;
+            public int NumCalls;
 
             public void Implode()
             {

com.unity.ml-agents/Tests/Editor/SamplerTests.cs

-using System;
-using System.Collections.Generic;
-using UnityEngine;
 using Unity.MLAgents.SideChannels;
 
 namespace Unity.MLAgents.Tests

com.unity.ml-agents/Tests/Editor/Sensor/SensorTestHelper.cs

 using NUnit.Framework;
-using UnityEngine;
 using Unity.MLAgents.Sensors;
 
 namespace Unity.MLAgents.Tests

com.unity.ml-agents/Tests/Editor/Sensor/StackingSensorTests.cs

 
             // Test mapping with number of layers not being multiple of 3
             var dummySensor = new Dummy3DSensor();
-            dummySensor.Shape = new int[] { 2, 2, 4 };
-            dummySensor.Mapping = new int[] { 0, 1, 2, 3 };
+            dummySensor.Shape = new[] { 2, 2, 4 };
+            dummySensor.Mapping = new[] { 0, 1, 2, 3 };
-            paddedDummySensor.Shape = new int[] { 2, 2, 4 };
-            paddedDummySensor.Mapping = new int[] { 0, 1, 2, 3, -1, -1 };
+            paddedDummySensor.Shape = new[] { 2, 2, 4 };
+            paddedDummySensor.Mapping = new[] { 0, 1, 2, 3, -1, -1 };
             var stackedPaddedDummySensor = new StackingSensor(paddedDummySensor, 2);
             Assert.AreEqual(stackedPaddedDummySensor.GetCompressedChannelMapping(), new[] { 0, 1, 2, 3, -1, -1, 4, 5, 6, 7, -1, -1 });
         }
         {
             var wrapped = new Dummy3DSensor();
-            wrapped.Shape = new int[] { 2, 1, 2 };
+            wrapped.Shape = new[] { 2, 1, 2 };
             var sensor = new StackingSensor(wrapped, 2);
 
             // Check the stacking is on the last dimension
         public void TestStackedGetCompressedObservation()
         {
             var wrapped = new Dummy3DSensor();
-            wrapped.Shape = new int[] { 1, 1, 3 };
+            wrapped.Shape = new[] { 1, 1, 3 };
             var sensor = new StackingSensor(wrapped, 2);
 
             wrapped.CurrentObservation = new[, ,] { { { 1f, 2f, 3f } } };