public ProcessStatus StartLongRunningProcess <T>(object inputParameter) where T : ILongRunningProcess
{
var process = CreateProcess <T>();
process.ProcessData.ProcessInstanceContainer.ProcessTypeData
.ProcessType = ProcessType.LongRunningProcess;
var vm = new VirtualMachine.VirtualMachine();
process.LongRunningProcessData.VirtualMachine = vm;
var result = vm.Start <object>("Start", process);
AfterRunProcess(process, result);
SaveProcess(process);
if (vm.Thread.Status == VirtualMachineState.Hibernated)
{
var processStatus = new ProcessStatus();
processStatus.Status = ProcessExecutionStaus.Pending;
processStatus.ProcessId = process.ProcessData.ProcessId;
processStatus.ProcessNumber = process.ProcessData.ProcessNumber;
return(processStatus);
}
else
{
throw new Exception("Process end immediately. It should use hibernation for long running process");
}
}
public void TestMethodMultiHibernation()
{
var proces = new HibernateWorkflowSimple()
{
InputParametr = 10
};
var vm = new VirtualMachine.VirtualMachine();
vm.Start(proces);
var serializedVMXml = vm.Serialize();
object retFromSerializedVM = "";
while (vm.Status == VirtualMachineState.Hibernated)
{
vm = VirtualMachine.VirtualMachine.Deserialize(serializedVMXml);
retFromSerializedVM = vm.Resume();
serializedVMXml = vm.Serialize();
}
var inProcProces = new HibernateWorkflowSimple()
{
InputParametr = 10
};
var retInProcProces = inProcProces.Start();
Assert.AreEqual(retInProcProces, retFromSerializedVM);
}
public void TestDwochKonstruktorow()
{
var proces = new DwaParametryProces();
var vm = new VirtualMachine.VirtualMachine();
var vmWynik = vm.Start(proces);
var wynik = proces.Start();
Assert.AreEqual(wynik, vmWynik);
}
public void Test_DodawaniePracownikaProces()
{
var proces = new DodawaniePracownikaProces();
var vm = new VirtualMachine.VirtualMachine();
var vmWynik = vm.Start(proces);
var wynik = proces.Start();
Assert.AreEqual(wynik, vmWynik);
}
public void TestMethod1()
{
var proces = new FluentUIProcess();
var vm = new VirtualMachine.VirtualMachine();
var vmWynik = vm.Start(proces);
proces = vm.Instance as FluentUIProcess;
proces = new FluentUIProcess();
var wynik = proces.Start();
Assert.AreEqual(wynik, vmWynik);
}
public void ArithmeticTest()
{
var proces = new ArithmeticProcess();
var vm = new VirtualMachine.VirtualMachine();
var vmWynik = vm.Start(proces);
proces = vm.Instance as ArithmeticProcess;
proces = new ArithmeticProcess();
var wynik = proces.Start();
Assert.AreEqual(wynik, vmWynik);
}
static void Main(string[] args)
{
FileReader f = new FileReader("thescript");
Tokenizr.Tokenizr t = new Tokenizr.Tokenizr(f.GetSplittedLines());
Console.WriteLine("\n===============Compiler=================== ");
Compiler.Compiler c = new Compiler.Compiler(t.Tokens);
Console.WriteLine("\n===============VirtualMachine============= ");
VirtualMachine.VirtualMachine vm = new VirtualMachine.VirtualMachine();
vm.Execute(c.Actions);
//vm.Print();
Console.ReadLine();
}
public void Test_RepozytoriumTestProces()
{
var proces = new RepozytoriumTestProces();
var vm = new VirtualMachine.VirtualMachine();
var vmWynik = vm.Start(proces) as List <Pracownik>;
var wynik = proces.Start() as List <Pracownik>;
Assert.AreEqual(wynik.Count, vmWynik.Count);
for (int i = 0; i < wynik.Count; i++)
{
Assert.AreEqual(wynik[i], vmWynik[i]);
}
}
public void TestMethod1()
{
var proces = new ProstaHibernacjaProces();
var vm = new VirtualMachine.VirtualMachine();
vm.Start(proces); //zwraca null, bo proces się zahibernował
Assert.IsTrue(vm.Status == VirtualMachineState.Hibernated);
vm.Resume(); //wznawiam wykonanie procesu -> po czym proces powinien znów się zahibernować
Assert.IsTrue(vm.Status == VirtualMachineState.Hibernated);
vm.Resume(); //wznawiam wykonanie procesu -> po czym proces powinien się zakończyć i zwrócić wynik wewnętrzny
Assert.IsTrue(vm.Status == VirtualMachineState.Executed);
var vmWynik = vm.Wynik;
var wynik = proces.Start();
Assert.AreEqual(wynik, vmWynik);
}
public void TestMethod2()
{
var proces = new HibernacjaProces();
var wynik = proces.Start(); //wynik procesu wykonanego 'natywnie'
proces = new HibernacjaProces();
var vm = new VirtualMachine.VirtualMachine();
vm.Start(proces); //zwraca null, bo proces się zahibernował
//wznawiam tyle razy ile potrzeba, tak żeby zakończyć proces
while (vm.Status == VirtualMachineState.Hibernated)
{
vm.Resume();
}
var vmWynik = vm.Wynik; //wynik procesu interpretowanego w VM
Assert.AreEqual(wynik, vmWynik);
}
public void TestMethod1()
{
var proces = new HibernateWorkflowSimple()
{
InputParametr = 10
};
var vm = new VirtualMachine.VirtualMachine();
vm.Start(proces);
var serializedVMXml = vm.Serialize();
var vmNew = VirtualMachine.VirtualMachine.Deserialize(serializedVMXml);
var retFromSerializedVM = vmNew.Resume();
var inProcProces = new HibernateWorkflowSimple()
{
InputParametr = 10
};
var retInProcProces = inProcProces.Start();
Assert.AreEqual(retInProcProces, retFromSerializedVM);
}
public ProcessContainer AddProcess(ProcessBase process)
{
if (process.Debug == true)
{
//uruchamiamy proces w trybie debug
var kontenerProcesu = new DebugProcesContainer()
{
Id = process.Id
};
kontenerProcesu.Process = process;
kontenerProcesu.Thread = new Thread(debugThread);
kontenerProcesu.Thread.Name = "proces " + process.Id;
process.Status = EnumProcessStatus.WaitingForExecution;
debugProcesess.Add(kontenerProcesu);
kontenerProcesu.Thread.Start(kontenerProcesu);
return(kontenerProcesu);
}
else
{
process.Status = EnumProcessStatus.WaitingForExecution;
var wm = new VirtualMachine.VirtualMachine();
//dodaje tylko do kolejki uruchomienia - nie uruchamiam w tym wątku
wm.Start(process, doExecuting: false);
var xml = wm.Serialize();
var serializedProcess = new ProcessContainer();
serializedProcess.Id = process.Id;
serializedProcess.Status = process.Status;
serializedProcess.ExecutionDate = process.ExecutionDate;
serializedProcess.VirtualMachineXml = xml;
dal.AddProcess(serializedProcess);
return(serializedProcess);
}
}
public void SetVirtualMachine(VirtualMachine.VirtualMachine vm)
{
VirtualMachineXml = vm.Serialize();
}
public static ProcessBase GetProcess(this VirtualMachine.VirtualMachine virtualMachine)
{
return(virtualMachine.Instance as ProcessBase);
}
static void Main(string[] args)
{
Tests();
_logger.Info("Run your ATC-8 Assembly commands: ");
try
{
var parser = new Parser();
var vm = new VirtualMachine.VirtualMachine();
while (true)
{
var currLine = Console.ReadLine();
if (string.IsNullOrEmpty(currLine))
{
_logger.Warning("The line is empty");
continue;
}
if (currLine.ToLower() == "help" || currLine.ToLower() == "?")
{
}
else if (currLine.ToLower() == "quit" || currLine.ToLower() == "exit" || currLine.ToLower() == "q")
{
break;
}
bool shouldViewBytecode = false;
if (currLine.EndsWith("|d"))
{
shouldViewBytecode = true;
currLine = currLine.Replace("|d", "");
}
Word[] bytecode;
try
{
bytecode = parser.ParseString(currLine + "\n");
}
catch (Exception e)
{
_logger.Error(e.Message);
continue;
}
if (shouldViewBytecode)
{
var maxBytesOnLine = 20;
Console.WriteLine();
for (int i = 0; i < bytecode.Length; i++)
{
if (maxBytesOnLine != 0 && i != 0 && i % maxBytesOnLine == 0)
{
Console.WriteLine();
}
Console.Write($"{((byte) bytecode[i]).ToHexString().ToUpper()} ");
}
Console.WriteLine("\n");
}
try
{
vm.Interpret(bytecode);
}
catch (Exception e)
{
_logger.Error(e.Message);
}
Console.WriteLine();
}
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadKey();
Environment.Exit(1);
}
Console.WriteLine("Success! Press any key to continue..");
Console.ReadKey();
}
private static void Tests()
{
Console.WriteLine(" ===== TESTS ===== \n");
var ax = new Register(RegisterName.Ax, 0xFA); // 0b11111010
var bx = new Register(RegisterName.Bx, 0x00); // 0b00000000
var cx = new Register(RegisterName.Cx, 0xFF); // 0b11111111
var dx = new Register(RegisterName.Dx, 0b10101010);
Console.WriteLine($"{ax} {bx} {cx} {dx}");
Console.WriteLine(((ax.Value << 16) >> 12) & 0xffff);
string test = "abcdefg";
var b = test.ToWordArray();
foreach (var word in b)
{
Console.Write($"{word} ");
}
Console.WriteLine();
var test2 = b.FromWordArray();
foreach (char ch in test2)
{
Console.Write($"{ch} ");
}
Console.WriteLine();
try
{
Parser parser = new Parser();
var bytecode = parser.ParseFile("test2.txt");
Console.WriteLine(Convert.ToString((sbyte)TokenType.Eof, 2));
for (int i = 0; i < bytecode.Length; i++)
{
if (i % 20 == 0)
{
Console.WriteLine();
}
if (bytecode[i] == ',' || bytecode[i] == '[' || bytecode[i] == ']')
{
Console.Write($"{(char)bytecode[i]} ");
}
else
{
Console.Write($"{bytecode[i]} ");
}
}
bytecode.SaveToFile("bytecode.txt", 20);
Console.WriteLine("\n");
VirtualMachine.VirtualMachine vm = new VirtualMachine.VirtualMachine();
//vm.Interpret(bytecode);
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadKey();
Environment.Exit(1);
}
Console.WriteLine(" ===== END TESTS ===== \n");
}
