AutomaticTestRunnerGUI.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.IO;
 
using Barotrauma;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Graphics;
using HarmonyLib;
using CrabUI;
using System.Text;
using System.Threading;
using Barotrauma.Extensions;
 
namespace CrabUITest
{
  public class AutoTestGUI
  {
    public class TestButton : CUIHorizontalList
    {
      public CUIButton RunButton;
      public CUIButton StashButton;
      public CUIToggleButton AutorunButton;
 
      public string Name
      {
        get => RunButton.Text;
        set => RunButton.Text = value;
      }
 
      public void UseReport(TestReport report)
      {
        RunButton.MasterColor = report.Status switch
        {
          TestStatus.Passed => Color.Lime,
          TestStatus.Unknown => Color.Yellow,
          TestStatus.Stashed => Color.Lime,
          TestStatus.Failed => Color.Red,
          _ => Color.White,
        };
      }
 
      public TestButton()
      {
        FitContent = new CUIBool2(true, true);
 
        this["RunButton"] = RunButton = new CUIButton()
        {
          FillEmptySpace = new CUIBool2(true, false),
          TextAlign = CUIAnchor.TopLeft,
          Style = new CUIStyle() {
            { "MasterColor", "128,128,128" },
            { "TextAlign", "[0,0]" },
            { "Border", "Transparent" },
          },
        };
 
        this["autorun"] = AutorunButton = new CUIToggleButton("A")
        {
          AbsoluteMin = new CUINullRect(w: 20),
          AddOnStateChange = (state) =>
          {
            DispatchUp(new CUICommand("set autorun", state ? Name : ""));
          },
          Style = new CUIStyle() {
            { "Border", "Transparent" },
            { "OnColor", "0,200,0"},
            { "OnHoverColor", "0,255,255"},
          },
        };
 
        this["StashButton"] = StashButton = new CUIButton()
        {
          Text = "stash",
          Style = new CUIStyle() {
            { "MasterColor", "255,0,255" },
            { "Border", "Transparent" },
          },
        };
 
        IgnoreDebug = true;
      }
 
      public TestButton(string name) : this()
      {
        Name = name;
      }
    }
 
 
    public AutomaticTestRunner Runner;
 
    public CUIButton OpenButton;
    public CUIFrame MainFrame;
 
    public CUIVerticalList CUITestList;
 
    public Dictionary<MethodInfo, TestButton> TestButtons = new();
 
    public bool Opened
    {
      get => MainFrame.Revealed;
      set
      {
        OpenButton.Revealed = !value;
        MainFrame.Revealed = value;
      }
    }
 
    public void UseConfig(TestingConfig config)
    {
      if (config.Autorun == "") return;
      (Type testClass, MethodInfo testMethod) = AutomaticTestRunner.DeconstructFullName(config.Autorun);
 
      if (TestButtons.ContainsKey(testMethod))
      {
        if (!TestButtons[testMethod].AutorunButton.State)
        {
          TestButtons[testMethod].AutorunButton.State = true;
        }
      }
    }
 
    public void FindTests()
    {
      TestButtons?.Clear();
      CUITestList?.RemoveAllChildren();
 
      foreach (Type testClass in Runner.GetAllTestClasses())
      {
        foreach (MethodInfo testMethod in Runner.GetAllTestMethodsForAClass(testClass))
        {
          TestButtons[testMethod] = new TestButton($"{testClass.Name}.{testMethod.Name}");
          TestButtons[testMethod].RunButton.OnMouseDown += (e) => Runner.RunTest(testClass, testMethod);
          TestButtons[testMethod].StashButton.OnMouseDown += (e) => Runner.StashTest(testClass, testMethod);
 
          CUITestList.Append(TestButtons[testMethod]);
        }
      }
    }
 
    public void CreateUI()
    {
      OpenButton = new CUIButton("TEST")
      {
        Vertical = true,
        Anchor = CUIAnchor.CenterRight,
        AddOnMouseDown = (e) => Opened = !Opened,
        Font = GUIStyle.MonospacedFont,
        ZIndex = 1001,
        AKA = "AutoTest open button",
      };
 
      MainFrame = new CUIFrame()
      {
        Anchor = CUIAnchor.CenterRight,
        Relative = new CUINullRect(0, 0, 0.2f, 0.4f),
        ZIndex = 1000,
        AKA = "AutoTest MainFrame"
      };
 
      MainFrame.SaveStateAs("init");
      MainFrame.OnDClick += (e) => MainFrame.LoadState("init");
      MainFrame.Revealed = false;
 
 
      MainFrame["list"] = new CUIVerticalList()
      {
        Relative = new CUINullRect(0, 0, 1, 1),
      };
 
      MainFrame["list"]["header"] = new CUIHorizontalList()
      {
        Absolute = new CUINullRect(h: 20),
      };
 
      MainFrame["list"]["header"]["main"] = new CUIHorizontalList()
      {
        FillEmptySpace = new CUIBool2(true, false),
      };
 
      MainFrame["list"]["header"]["main"]["caption"] = new CUITextBlock("Test")
      {
        TextAlign = CUIAnchor.Center,
      };
      MainFrame["list"]["header"]["main"]["runall"] = new CUIButton("Run all")
      {
        AddOnMouseDown = (e) => Runner.RunAllTests(),
      };
      MainFrame["list"]["header"]["main"]["end"] = new CUIButton("End test")
      {
        AddOnMouseDown = (e) => Runner.StopTest(),
      };
      MainFrame["list"]["header"]["main"]["clear"] = new CUIButton("clear stash")
      {
        AddOnMouseDown = (e) => Runner.ClearStash(),
        Style = new CUIStyle() { { "MasterColor", "Red" } },
      };
 
      MainFrame["list"]["header"]["closebutton"] = new CUIButton("X")
      {
        Style = new CUIStyle() { { "MasterColor", "Red" } },
        AddOnMouseDown = (e) => Opened = false,
        Font = GUIStyle.MonospacedFont,
      };
 
 
 
      MainFrame["list"]["testlist"] = CUITestList = new CUIVerticalList()
      {
        FillEmptySpace = new CUIBool2(false, true),
        Scrollable = true,
      };
 
      MainFrame.IgnoreDebug = true;
      OpenButton.IgnoreDebug = true;
 
      CUI.Main.Append(MainFrame);
      CUI.Main.Append(OpenButton);
    }
 
    public AutoTestGUI(AutomaticTestRunner runner)
    {
      Runner = runner;
      CreateUI();
      FindTests();
 
      MainFrame.AddCommand("set autorun", (o) => runner.Config.Autorun = (string)o);
 
      Runner.OnTestReport += (report) =>
      {
        TestButtons.GetValueOrDefault(report.TestMethod)?.UseReport(report);
      };
    }
  }
 
}