BadUnitTestContext.cs

Go to the documentation of this file.

using BadScript2.Interop.Common.Task;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
 
using NUnit.Framework;
 
namespace BadScript2.Interop.NUnit;
 
public class BadUnitTestContext
{
    private readonly List<BadNUnitTestCase> m_Cases;
 
    private readonly BadRuntime m_Runtime;
 
    private readonly List<BadFunction> m_Setup;
 
    private readonly List<BadFunction> m_Teardown;
 
    private readonly string m_WorkingDir;
 
    public BadUnitTestContext(string workingDir,
                              List<BadNUnitTestCase> cases,
                              List<BadFunction> setup,
                              List<BadFunction> teardown,
                              BadRuntime runtime)
    {
        m_Cases = cases;
        m_Setup = setup;
        m_Teardown = teardown;
        m_Runtime = runtime;
        m_WorkingDir = workingDir;
    }
 
    private static void Run(IEnumerable<BadObject> enumerable)
    {
        foreach (BadObject _ in enumerable)
        {
            //Execute
        }
    }
 
    public void Setup()
    {
        Run(RunSetup());
    }
 
    public void Teardown()
    {
        Run(RunTeardown());
    }
 
    public void Run(BadNUnitTestCase test)
    {
        Run(RunTestCase(test));
    }
 
    public BadNUnitTestCase[] GetTestCases()
    {
        return m_Cases.ToArray();
    }
 
    public IEnumerable<BadObject> RunSetup()
    {
        for (int i = m_Setup.Count - 1; i >= 0; i--)
        {
            BadFunction function = m_Setup[i];
            BadExecutionContext caller = m_Runtime.CreateContext(m_WorkingDir);
 
            foreach (BadObject o in function.Invoke(Array.Empty<BadObject>(), caller))
            {
                yield return o;
            }
        }
    }
 
    public IEnumerable<BadObject> RunTeardown()
    {
        for (int i = m_Teardown.Count - 1; i >= 0; i--)
        {
            BadFunction function = m_Teardown[i];
            BadExecutionContext caller = m_Runtime.CreateContext(m_WorkingDir);
 
            foreach (BadObject o in function.Invoke(Array.Empty<BadObject>(), caller))
            {
                yield return o;
            }
        }
    }
 
    private IEnumerable<BadObject> RunTestCase(BadNUnitTestCase testCase)
    {
        TestContext.WriteLine($"Running test '{testCase.TestName}'");
        BadExecutionContext caller = m_Runtime.CreateContext(m_WorkingDir);
 
        BadTaskRunner.Instance.AddTask(new BadTask(new BadInteropRunnable(testCase.Function!
                                                                              .Invoke(Array.Empty<BadObject>(), caller)
                                                                              .GetEnumerator()
                                                                         ),
                                                   testCase.TestName
                                                  ),
                                       true
                                      );
 
        while (!BadTaskRunner.Instance.IsIdle)
        {
            BadTaskRunner.Instance.RunStep();
 
            yield return BadObject.Null;
        }
    }
}