M/VisualSapfor
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert "упорядочил папки с кодом."

Browse Source 
This reverts commit 44c6daffa3.
This commit is contained in:
02090095
2023-11-19 02:12:44 +03:00
parent 44c6daffa3
commit 28908bcfac
596 changed files with 1569 additions and 2140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/TestingSystem/DVM/Tasks/TestCompilationTask.java Normal file
View File

@@ -0,0 +1,51 @@
package TestingSystem.DVM.Tasks;
import Common.Database.DBObject;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
//-
public class TestCompilationTask extends TestTask {
@Description("DEFAULT ''")
public String makefile_text = "";
@Description("DEFAULT ''")
public String test_home = ""; //место где лежит код теста.
@Description("IGNORE")
public Vector<TestRunTask> runTasks = null;
@Override
public Vector<String> pack(int kernels_in) {
Vector<String> res = new Vector<>();
res.add(String.valueOf(id)); //1
res.add(String.valueOf(maxtime)); //2
res.add(String.valueOf(test_id)); //3
res.add(makefile_text.replace("\n", "|")); //4
//игнор аргумента. ядро всегда одно.
return res;
}
public TestCompilationTask() {
}
public TestCompilationTask(Configuration configuration, Group group, Test test, String flags_in) {
super(configuration, group, test, flags_in);
flags = flags_in;
maxtime = configuration.c_maxtime;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TestCompilationTask ct = (TestCompilationTask) src;
makefile_text = ct.makefile_text;
test_home = ct.test_home;
if (ct.runTasks == null) this.runTasks = null;
else {
this.runTasks = new Vector<>();
for (TestRunTask runTask : ct.runTasks) {
this.runTasks.add(new TestRunTask(runTask));
}
}
}
public TestCompilationTask(TestCompilationTask src) {
this.SynchronizeFields(src);
}
}

16
src/TestingSystem/DVM/Tasks/TestCompilationTasksDBTable.java Normal file
View File

@@ -0,0 +1,16 @@
package TestingSystem.DVM.Tasks;
import Common.Current;
import Common.Database.DBTable;
public class TestCompilationTasksDBTable extends DBTable<Integer, TestCompilationTask> {
public TestCompilationTasksDBTable() {
super(Integer.class, TestCompilationTask.class);
}
@Override
public String getSingleDescription() {
return "задачи на компиляцию тестов";
}
@Override
public Current CurrentName() {
return Current.TestCompilationTask;
}
}

106
src/TestingSystem/DVM/Tasks/TestRunTask.java Normal file
View File

@@ -0,0 +1,106 @@
package TestingSystem.DVM.Tasks;
import Common.Constants;
import Common.Database.DBObject;
import GlobalData.Tasks.TaskState;
import ProjectData.LanguageName;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
public class TestRunTask extends TestTask {
//не факт что тут нужно переводить на полный интерфейс. достаточно убрать фильтрацию
@Override
public boolean isVisible() {
return TestRunTaskInterface.isVisible(this);
}
//--
public long testcompilationtask_id = Constants.Nan;
public String matrix = "";
@Description("DEFAULT ''")
public String args = "";
public double CleanTime = 0.0;
@Description("DEFAULT 0")
public int progress = 0;
public LanguageName language = LanguageName.fortran;
public int cube = 1;
public int min_dim = 1;
public int max_dim = 1;
public String environments = "";
public String usr_par = "";
public int compilation_maxtime = 40;
public String compilation_output = "";
public String compilation_errors = "";
public TaskState compilation_state = TaskState.Waiting;
public double compilation_time = 0.0;
public String statistic = "";
public String jsonStatistic = "";
public TestRunTask(Configuration configuration,
Group group, Test test,
String matrix_in, String flags_in,
String environments_in,
String par_in) {
super(configuration, group, test, flags_in);
//--------------------------
//инфа о компиляции.
language = group.language;
compilation_maxtime = configuration.c_maxtime;
compilation_output = "";
compilation_errors = "";
compilation_state = TaskState.Waiting;
//инфа о запуске
cube = configuration.cube;
min_dim = configuration.max_dim_proc_count;
max_dim = configuration.max_dim_proc_count;
maxtime = configuration.r_maxtime;
environments = environments_in;
usr_par = par_in;
args = test.args;
//---------
matrix = matrix_in;
}
public TestRunTask() {
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TestRunTask rt = (TestRunTask) src;
testcompilationtask_id = rt.testcompilationtask_id;
matrix = rt.matrix;
CleanTime = rt.CleanTime;
progress = rt.progress;
language = rt.language;
cube = rt.cube;
min_dim = rt.min_dim;
max_dim = rt.max_dim;
maxtime = rt.maxtime;
environments = rt.environments;
usr_par = rt.usr_par;
compilation_maxtime = rt.compilation_maxtime;
compilation_output = rt.compilation_output;
compilation_errors = rt.compilation_errors;
compilation_state = rt.compilation_state;
compilation_time = rt.compilation_time;
statistic = rt.statistic;
args = rt.args;
jsonStatistic = rt.jsonStatistic;
}
public TestRunTask(TestRunTask src) {
this.SynchronizeFields(src);
}
//-
@Override
public Vector<String> pack(int kernels_in) {
Vector<String> res = new Vector<>();
res.add(String.valueOf(id)); //1
res.add(String.valueOf(maxtime)); //2
res.add(String.valueOf(testcompilationtask_id)); //3
res.add(matrix); //4
res.add(environments); //5
res.add(usr_par.replace("\n", "|")); //6
res.add(args); //7
res.add(String.valueOf(kernels_in)); //8
return res;
}
}

83
src/TestingSystem/DVM/Tasks/TestRunTaskInterface.java Normal file
View File

@@ -0,0 +1,83 @@
package TestingSystem.DVM.Tasks;
import Common.Current;
import Common.Global;
import Common.Utils.StringTemplate;
import GlobalData.Tasks.TaskState;
import javafx.util.Pair;
import java.util.List;
public class TestRunTaskInterface {
public static boolean isVisible(TestRunTask object) {
return
Current.HasTasksPackage() &&
object.taskspackage_id.equals(Current.getTasksPackage().id) &&
Global.testingServer.account_db.testRunTasks.applyFilters(object);
}
public static String getEnvironments(TestRunTask object) {
return object.environments.replace("\n", ";");
}
public static String getUsrPar(TestRunTask object) {
return object.usr_par.replace("\n", ";");
}
//--
public static boolean isCrushedLine(String line) {
return line.contains("RTS err")
|| line.contains("RTS stack trace")
|| line.contains("RTS fatal err")
|| line.contains("SIGEGV")
|| line.contains("There are not enough slots available in the system to satisfy the")
|| line.contains("forrtl: severe")
|| line.contains("invalid pointer")
|| line.contains("forrtl: error");
}
public static boolean isCrushed(List<String> output_lines, List<String> errors_lines) {
return output_lines.stream().anyMatch(TestRunTaskInterface::isCrushedLine) || errors_lines.stream().anyMatch(TestRunTaskInterface::isCrushedLine);
}
public static Pair<TaskState, Integer> analyzeCorrectness(List<String> lines) {
int complete = 0;
int errors = 0;
int total = 0;
for (String s : lines) {
String line = s.toUpperCase();
if (line.contains("COMPLETE")) {
complete++;
total++;
} else if (line.contains("ERROR")) {
errors++;
total++;
}
}
return new Pair<>(
(errors > 0) ? TaskState.DoneWithErrors : ((complete > 0) ? TaskState.Done : TaskState.WrongTestFormat),
(int) ((((double) complete) / total) * 100)
);
}
public static Pair<TaskState, Integer> analyzePerformance(List<String> lines) {
StringTemplate stringTemplate = new StringTemplate("Verification =", "");
for (String line : lines) {
String param = stringTemplate.check_and_get_param(line);
if (param != null) {
switch (param) {
case "SUCCESSFUL":
return new Pair<>(TaskState.Done, 100);
case "UNSUCCESSFUL":
return new Pair<>(TaskState.DoneWithErrors, 0);
default:
break;
}
}
}
return new Pair<>(TaskState.WrongTestFormat, 0);
}
public static double parseCleanTime(String output) {
double res = 0.0;
StringTemplate template = new StringTemplate("Time in seconds =", "");
String p = template.check_and_get_param(output);
try {
if (p != null) res = Double.parseDouble(p);
} catch (Exception ex) {
Global.Log.PrintException(ex);
}
return res;
}
}

188
src/TestingSystem/DVM/Tasks/TestRunTasksDBTable.java Normal file
View File

@@ -0,0 +1,188 @@
package TestingSystem.DVM.Tasks;
import Common.Current;
import Common.Database.DBTable;
import Common.Database.TableFilter;
import Common.UI.DataSetControlForm;
import Common.UI.Menus_2023.TestRunTasksMenuBar.TestRunTasksMenuBar;
import Common.UI.Menus_2023.VisualiserMenu;
import Common.UI.UI;
import GlobalData.Tasks.TaskState;
import javax.swing.*;
import java.util.Comparator;
import java.util.Vector;
import static Common.UI.Tables.TableRenderers.RendererProgress;
import static Common.UI.Tables.TableRenderers.RendererStatusEnum;
public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
public Vector<TableFilter<TestRunTask>> compilationFilters;
public Vector<TableFilter<TestRunTask>> runFilters;
public TestRunTasksDBTable() {
super(Long.class, TestRunTask.class);
//--
if (Current.hasUI()) {
compilationFilters = new Vector<>();
runFilters = new Vector<>();
//--
for (TaskState state : TaskState.values()) {
if (state.isVisible()) {
compilationFilters.add(new TableFilter<TestRunTask>(this, state.getDescription()) {
@Override
protected boolean validate(TestRunTask object) {
return object.compilation_state.equals(state);
}
});
}
}
//--
for (TaskState state : TaskState.values()) {
if (state.isVisible()) {
runFilters.add(new TableFilter<TestRunTask>(this, state.getDescription()) {
@Override
protected boolean validate(TestRunTask object) {
return object.state.equals(state);
}
});
}
}
}
}
public void ResetFiltersCount() {
for (TableFilter<TestRunTask> filter : compilationFilters)
filter.count = 0;
for (TableFilter<TestRunTask> filter : runFilters)
filter.count = 0;
}
public void ShowFiltersCount() {
for (TableFilter<TestRunTask> filter : compilationFilters) {
filter.ShowDescriptionAndCount();
}
for (TableFilter<TestRunTask> filter : runFilters) {
filter.ShowDescriptionAndCount();
}
}
public boolean applyFilters(TestRunTask object) {
for (TableFilter<TestRunTask> filter : compilationFilters)
if (!filter.Validate(object)) return false;
for (TableFilter<TestRunTask> filter : runFilters)
if (!filter.Validate(object)) return false;
return true;
}
@Override
public String getSingleDescription() {
return "задача";
}
@Override
public String getPluralDescription() {
return "задачи";
}
@Override
protected DataSetControlForm createUI() {
return new DataSetControlForm(this) {
@Override
public boolean hasCheckBox() {
return true;
}
@Override
protected void AdditionalInitColumns() {
columns.get(2).setVisible(false);
columns.get(6).setRenderer(RendererStatusEnum);
columns.get(7).setRenderer(RendererStatusEnum);
columns.get(14).setRenderer(RendererProgress);
}
};
}
@Override
public void mountUI(JPanel content_in) {
super.mountUI(content_in);
//-
TestRunTasksMenuBar menuBar = (TestRunTasksMenuBar) UI.menuBars.get(getClass());
menuBar.DropFilters();
//----
menuBar.addFilters(
new VisualiserMenu("Компиляция", "/icons/Filter.png", true) {
{
for (TableFilter filter : compilationFilters)
add(filter.menuItem);
}
},
new VisualiserMenu("Запуск", "/icons/Filter.png", true) {
{
for (TableFilter filter : runFilters)
add(filter.menuItem);
}
}
);
}
@Override
public String[] getUIColumnNames() {
return new String[]{
"Группа",
"Тест",
"Язык",
"Флаги",
"Сборка",
"Запуск",
"Время компиляции(с)",
"Матрица",
"Окружение",
"usr.par",
"Время выполнения (с)",
"Чистое время (с)",
"Прогресс",
};
}
@Override
public Object getFieldAt(TestRunTask object, int columnIndex) {
switch (columnIndex) {
case 2:
return object.group_description;
case 3:
return object.test_description;
case 4:
return object.language;
case 5:
return object.flags;
case 6:
return object.compilation_state;
case 7:
return object.state;
case 8:
return object.compilation_time;
case 9:
return object.matrix;
case 10:
return TestRunTaskInterface.getEnvironments(object);
case 11:
return TestRunTaskInterface.getUsrPar(object);
case 12:
return object.Time;
case 13:
return object.CleanTime;
case 14:
return object.progress;
default:
return null;
}
}
@Override
public Comparator<TestRunTask> getComparator() {
return (o1, o2) -> -o1.getChangeDate().compareTo(o2.getChangeDate());
}
@Override
public Current CurrentName() {
return Current.TestRunTask;
}
@Override
public void ShowUI() {
ResetFiltersCount();
super.ShowUI();
ShowFiltersCount();
}
@Override
public void ShowUI(Object key) {
ResetFiltersCount();
super.ShowUI(key);
ShowFiltersCount();
}
}

99
src/TestingSystem/DVM/Tasks/TestTask.java Normal file
View File

@@ -0,0 +1,99 @@
package TestingSystem.DVM.Tasks;
import Common.Constants;
import Common.Database.DBObject;
import GlobalData.Tasks.TaskState;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.Common.Test.TestType;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Date;
import java.util.Vector;
//тут все поля должны быть текстовыми. никаких ссылок по ид. мало ли, группу удалят
public class TestTask extends DBObject {
@Description("PRIMARY KEY, UNIQUE")
public long id = Constants.Nan;
@Description("DEFAULT ''")
public String taskspackage_id = "";
@Description("DEFAULT -1")
public int group_id = Constants.Nan;
@Description("DEFAULT ''")
public String group_description = ""; //видимое имя группы для юзера
@Description("DEFAULT -1")
public int test_id = Constants.Nan; //ключ - будет генерироваться автоматически.
@Description("DEFAULT ''")
public String test_description = ""; //видимое имя теста для юзера
@Description("DEFAULT ''")
public String flags = "";
@Description("DEFAULT 'Inactive'")
public TaskState state = TaskState.Inactive;
@Description("DEFAULT ''")
public String PID = "";
@Description("DEFAULT 40")
public int maxtime = 40;
@Description("DEFAULT ''")
public String remote_workspace = ""; //вывести. память экономим.
@Description("DEFAULT ''")
public String binary_name = ""; //вывести. имя генерим по ид задачи и матрице.
@Description("DEFAULT 'Default'")
public TestType test_type = TestType.Default;
//результаты-------------------------------
public double Time; //время выполнения.
public long StartDate = 0; //дата начала выполнения
public long ChangeDate = 0;//дата изменения
@Description("DEFAULT ''")
public String output = "";
@Description("DEFAULT ''")
public String errors = "";
//------------------------------------------------------
@Override
public Object getPK() {
return id;
}
public Date getChangeDate() {
return new Date(ChangeDate);
}
//--->>>
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TestTask t = (TestTask) src;
id = t.id;
taskspackage_id = t.taskspackage_id;
group_id = t.group_id;
group_description = t.group_description;
test_id = t.test_id;
test_description = t.test_description;
flags = t.flags;
state = t.state;
PID = t.PID;
maxtime = t.maxtime;
remote_workspace = t.remote_workspace;
binary_name = t.binary_name;
test_type = t.test_type;
Time = t.Time;
StartDate = t.StartDate;
ChangeDate = t.ChangeDate;
output = t.output;
errors = t.errors;
}
public TestTask(TestTask src) {
this.SynchronizeFields(src);
}
public TestTask() {
}
public TestTask(Configuration configuration,
Group group, Test test, String flags_in) {
group_id = group.id;
test_id = test.id;
group_description = group.description;
test_description = test.description;
test_type = group.type;
flags = flags_in;
}
public Vector<String> pack (int kernels){
return null;
}
}