package bluej.pkgmgr;

import bluej.Config;
import bluej.collect.DataCollector;
import bluej.debugger.DebuggerTestResult;
import bluej.debugger.jdi.TestResultsWithRunTime;
import bluej.pkgmgr.target.ClassTarget;
import bluej.pkgmgr.target.role.UnitTestClassRole;
import bluej.testmgr.TestDisplayFrame;
import bluej.utility.Debug;
import javafx.application.Platform;
import threadchecker.OnThread;
import threadchecker.Tag;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;




| Provide a thread class for running unit tests.
|
| Unit tests are user code so they must be executed on a seperate thread.
| This class provides the means to do this.
|
| There are two primary modes of operation: run a single test (methodname != null),
| and run all tests for a series of ClassTargets.
|
| @author Davin McCall
|
public class TestRunnerThread
extends Thread{
   @OnThread(Tag.Worker)
   
   private final Iterator<ClassTarget> testIterator;
   
   private final PkgMgrFrame pmf;

   
   private final String methodName; 
    
   
   private int state;
   
   private final Project project;

   
   


| Construct a test runner thread for running multiple tests.
|
@OnThread(Tag.FXPlatform)
   
   public TestRunnerThread(PkgMgrFrame pmf, Iterator<ClassTarget> i)
   {        
      this.pmf = pmf;
      this.project = pmf.getProject();
       
      this.methodName = null;
       
      testIterator = i;
       
      state = 0;     
      }
    
   
   


| Construct a test runner thread for running a single test.
|
@OnThread(Tag.FXPlatform)
   
   public TestRunnerThread(PkgMgrFrame pmf, ClassTarget ct, String methodName)
   {        
      this.pmf = pmf;
      this.project = pmf.getProject();
       
      List<ClassTarget> l = new ArrayList<ClassTarget>(1);
      l.add(ct);
      testIterator = l.iterator();
       
      this.methodName = methodName;
       
      state = 0;     
      }

   @OnThread(value = Tag.Worker, ignoreParent = true)
   
   public void run()
   {
      while (testIterator.hasNext()) 
       { 
         ClassTarget ct = testIterator.next();

           
         List<String> allMethods;
         if (methodName == null)
           {                
            
            CompletableFuture<List<String>> methodsFuture = new CompletableFuture<>();
            Platform.runLater(() -> startTestFindMethods(ct, methodsFuture));
               
            try
               {
               allMethods = methodsFuture.get();                 
               }
               
            catch (InterruptedException | ExecutionException e)
               {
               Debug.reportError(e);
               allMethods = Collections.emptyList();                 
               }             
            }
           

         else 
           {                
            
            allMethods = Arrays.asList(methodName);             
            }

           
         
         if (allMethods.size() == 1)
           {
            TestResultsWithRunTime lastResult = project.getDebugger().runTestMethod(ct.getQualifiedName(), methodName);
               
            
            Platform.runLater(() -> showNextResult(lastResult.getResults().get(0)));             
            }
           

         else
           {
            TestResultsWithRunTime lastResults = project.getDebugger().runTestMethod(ct.getQualifiedName(), null);
               
            
            for (DebuggerTestResult result : lastResults.getResults())
               {
               Platform.runLater(() -> showNextResult(result));                 
               }
            Platform.runLater(() -> TestDisplayFrame.getTestDisplay()
            .setTotalTimeMs(lastResults.getTotalRunTime()));             
            }         
         }

       
      
      Platform.runLater(() -> {
      if (methodName == null)
      pmf.endTestRun();         
      });
   }

@OnThread(Tag.FXPlatform)
   
private void showNextResult(DebuggerTestResult lastResult)
   {        
   
   boolean quiet = methodName != null && lastResult.isSuccess();
   TestDisplayFrame.getTestDisplay().addResult(lastResult, quiet);

   if (quiet)
   pmf.setStatus(methodName + " " + Config.getString("pkgmgr.test.succeeded"));

   DataCollector.testResult(pmf.getPackage(), lastResult);     
   }

@OnThread(Tag.FXPlatform)
   
private void startTestFindMethods(ClassTarget ct, CompletableFuture<List<String>> methodsFuture)
   {        
   
   
   

   if (ct.isCompiled() && ct.isUnitTest() && ! ct.isAbstract()) {
      UnitTestClassRole utcr = (UnitTestClassRole) ct.getRole();

      List<String> allMethods = utcr.startRunTest(pmf, ct, TestRunnerThread.this);
      if (allMethods == null)
      methodsFuture.complete(Collections.emptyList());
           
      else{ methodsFuture.complete(allMethods);
         }         
      }
       

   else {
   methodsFuture.complete(Collections.emptyList());         
   }     
} 
}