public void Get_GetComputer_ValidateReturn(Computer computer)
{
//Given
using (var context = new HardwareContext(_options))
{
context.Computers.Add(computer);
context.SaveChanges();
}
//When
using (var context = new HardwareContext(_options))
{
Assert.Equal(1, context.Computers.Count());
}
ActionResult <Computer> result;
//Then
using (var context = new HardwareContext(_options))
{
var computersController = new ComputersController(context);
result = computersController.Get(computer.Id);
}
var okResult = Assert.IsType <OkObjectResult>(result.Result);
var value = Assert.IsType <Computer>(okResult.Value);
Assert.Equal(computer, value, new ModelEqualityComparer <Computer>());
}
public async Task Get_GetScan_ValidateReturn(Scan scan)
{
//Given
using (var context = new HardwareContext(_options))
{
context.Scans.Add(scan);
context.SaveChanges();
}
//When
using (var context = new HardwareContext(_options))
{
Assert.Equal(1, context.Scans.Count());
}
ActionResult <Scan> result;
//Then
using (var context = new HardwareContext(_options))
{
var scansController = new ScansController(context);
result = await scansController.GetScan(scan.Id);
}
var okResult = Assert.IsType <OkObjectResult>(result.Result);
var value = Assert.IsType <Scan>(okResult.Value);
Assert.Equal(scan.Computer?.Id, value.Computer?.Id);
Assert.Equal(scan.User?.Id, value.User?.Id);
Assert.Equal(scan.CreationDateTime, value.CreationDateTime);
}
public void Setup()
{
_tOptionsBuilder = new DbContextOptionsBuilder <TransactionContext>().UseSqlServer("Server = (localdb)\\mssqllocaldb; Database = TransactionsDatabase; Trusted_Connection = True; MultipleActiveResultSets = true");
_tOptions = _tOptionsBuilder.Options;
_tContext = new TransactionContext(_tOptions);
_hOptionsBuilder = new DbContextOptionsBuilder <HardwareContext>().UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=HardwareDatabase;Trusted_Connection=True;MultipleActiveResultSets=true");
_hOptions = _hOptionsBuilder.Options;
_hContext = new HardwareContext(_hOptions);
}
public override void Wykonaj()
{
//mamy wynik
object wynik = "null";
//sprawdzam czy jest coś jeszcze na stosie, jeśli jet to jest to wynik, który trzeba zwrócić
if (MethodContext.EvaluationStack.IsEmpty())
{
EventRet();
//mamy koniec wykonywania procedury (bez wyniku)
//MethodContext.CzyWykonywacInstrukcje = false;
//WirtualnaMaszyna.Status = VirtualMachineState.Executed;
// return;
}
else
{
// mamy wynik metody, pobieram ze stosu
wynik = PopObject();
//loguje wykonanie ret
EventRet(wynik);
}
//mamy inne metody na stosie wywołań - przekazuje ostatniej wynik
//ściągam ze stosu obecną metodę
HardwareContext.PopMethodState();
//sprawdzam czy koniec wykonania VM - jest coś jeszcze na stosie wywołań - jeśli nie to kończymy wątek i wirtualną maszynę
if (HardwareContext.CallStack.IsEmpty())
{
//mamy koniec wykonywania funkcji (zwracającej wynik)
MethodContext.CzyWykonywacInstrukcje = false;
HardwareContext.Status = VirtualMachineState.Executed;
HardwareContext.Result = wynik; //zwracam wynik na stosie
return;
}
var metodaDoWznowienia = HardwareContext.AktualnaMetoda;
if (wynik == "null")
{
//metoda bez wyniku
}
else
{
metodaDoWznowienia.PushObject(wynik);
}
metodaDoWznowienia.NumerWykonywanejInstrukcji++;
}
private void WriteProc()
{
while (true)
{
for (var i = 0; i < queryIntervalMilliSec / interrupIntervalMilliSec; ++i)
{
if (shutdownRequest.WaitOne(interrupIntervalMilliSec))
{
return; // тут кто-то сказал нам, что приложение нужно стопнуть
}
}
lock (sync)
{ // обновляем данные
using (Dbcontext = new HardwareContext())
{
Write();
}
}
}
}
public void Post_InsertComputer_ValidateExists(Computer computer)
{
using (var context = new HardwareContext(_options))
{
var computersController = new ComputersController(context);
computersController.PostBody(computer);
}
using (var context = new HardwareContext(_options))
{
Assert.Equal(1, context.Computers.Count());
Assert.Equal(computer, context.Computers.Include(c => c.Disks)
.Include(c => c.Gpus)
.ThenInclude(g => g.Memory)
.Include(c => c.Memories)
.Include(c => c.MotherBoard)
.Include(c => c.Processor)
.Single(), new ModelEqualityComparer <Computer>());
}
}
public void GetOrderedWorkList_OrderHighToLow()
{
var dbContext = new HardwareContext(_options);
var adapter = new BotDbContextAdapter(dbContext);
var worksDict = new Dictionary <string, int>
{
{ "Student", 10 },
{ "HiTech", 4 },
{ "FFF", 3 }
};
dbContext.Users.AddRange(worksDict.SelectMany(kv => GenerateUsersForWork(kv.Key, kv.Value)));
dbContext.SaveChanges();
var orderedList = adapter.GetOrderedWorkList().ToArray();
Assert.Equal(worksDict.Count, orderedList.Length);
for (int i = 0; i < worksDict.Count; i++)
{
Assert.Equal(worksDict.Keys.ElementAt(i), orderedList[i]);
}
}
public async Task Post_InsertScan_ValidateExists(Scan scan)
{
var now = DateTime.Now;
using (var context = new HardwareContext(_options))
{
var scansController = new ScansController(context);
await scansController.PostNewScanByComputer(scan.Computer);
}
using (var context = new HardwareContext(_options))
{
Assert.Equal(1, context.Scans.Count());
var actual = context.Scans.Include(s => s.User)
.Include(s => s.Computer).Single();
Assert.NotEqual(Guid.Empty, actual.Id);
Assert.Null(actual.User);
Assert.True(actual.CreationDateTime > now, $"{actual.CreationDateTime} > {now}");
Assert.True(actual.CreationDateTime < DateTime.Now, $"{actual.CreationDateTime} < {DateTime.Now}");
Assert.Equal(scan.Computer?.Id, actual.Computer?.Id);
}
}
public TestStringsController(HardwareContext context)
{
_context = context;
}
public ScansController(HardwareContext context)
{
_context = context;
}
public ComputersController(HardwareContext context) : base(context)
{
}
static HardwareDB()
{
Hcon = new HardwareContext();
}
protected GenericControllerBase(HardwareContext context)
{
Context = context;
}
public override void Wykonaj()
{
var method = Instruction.Operand as System.Reflection.MethodBase;
//var methodDef = methodRef.Resolve();
var parameters = new List <object>();
object instance = null;
object instancePop = null;
foreach (var paramDef in method.GetParameters())
{
parameters.Add(MethodContext.PopObject());
}
if (method.IsStatic == false)
{
instancePop = MethodContext.Pop();
if (instancePop is ObjectWraperBase wraper)
{
instance = wraper.GetValue();
}
else
{
instance = instancePop;
}
}
parameters.Reverse();
MethodContext.WirtualnaMaszyna.EventCall(method, parameters);
if (method.Name.Equals("Hibernate") && method.DeclaringType == typeof(VirtualMachine))
{
//wywołał metodę do hibernacji wirtualnej maszyny
if (parameters.Count > 0)
{
var p = (object[])parameters[0];
this.MethodContext.WirtualnaMaszyna.HibernateVirtualMachine(p);
}
else
{
this.MethodContext.WirtualnaMaszyna.HibernateVirtualMachine(null);
}
return;
}
if (method.Name.Equals("EndProcess") && method.DeclaringType == typeof(VirtualMachine))
{
//wywołał metodę do hibernacji wirtualnej maszyny
this.MethodContext.WirtualnaMaszyna.EndProcessVirtualMachine();
return;
}
//if (method.IsSetter)
//{
// setter(methodDef, instance, parameters);
//}
//else if (methodDef.IsGetter)
//{
// getter(methodRef, instance, parameters);
//}
//else
{
//Wykonywanie
if (CzyWykonacCzyInterpretowac(method, instance) == true)
{
//wykonywanie
//var methodInfo = type.GetMethod(methodRef);
var dopasowaneParametry = new List <object>();
int i = 0;
foreach (var parameter in parameters)
{
var methodParam = method.GetParameters()[i];
i++;
if (methodParam.ParameterType == typeof(bool) && parameter is int)
{
dopasowaneParametry.Add(Convert.ToBoolean((int)parameter));
}
else
{
dopasowaneParametry.Add(parameter);
}
}
object ret = null;
try
{
if (method.IsConstructor == true)
{
var constructor = method as ConstructorInfo;
ret = constructor.Invoke(dopasowaneParametry.ToArray());
//po wykonaniu odznaczam że był powrót z funkcji (bo już nie będzie instrukcji ret)
MethodContext.WirtualnaMaszyna.EventRet(ret);
if (instancePop is ObjectWraperBase wraperBase)
{
wraperBase.SetValue(ret);
}
else
{
MethodContext.PushObject(ret);
}
}
else if (instance == null && method.IsStatic == false)
{
//wykonywanie metody nie statycznej dla instance==null np. null.Equals(..)
var expressionParameters = new List <UnaryExpression>();
i = 0;
foreach (var item in dopasowaneParametry)
{
var methodParam = method.GetParameters()[i];
i++;
expressionParameters
.Add(Expression.Convert(Expression.Constant(item), methodParam.ParameterType));
}
var call = Expression.Call(Expression.Constant(instance,
//typeof(int?)),
//method.DeclaringType),
MethodContext.ConstrainedType), //ConstrainedType set by Constrained instruction
(MethodInfo)method,
expressionParameters);
MethodContext.ConstrainedType = null;
var lambda = Expression.Lambda(call).Compile();
ret = lambda.DynamicInvoke();
//po wykonaniu odznaczam że był powrót z funkcji (bo już nie będzie instrukcji ret)
MethodContext.WirtualnaMaszyna.EventRet(ret);
}
else
{
//standardowe wykonywanie metod
ret = method.Invoke(instance, dopasowaneParametry.ToArray());
//po wykonaniu odznaczam że był powrót z funkcji (bo już nie będzie instrukcji ret)
MethodContext.WirtualnaMaszyna.EventRet(ret);
}
} catch (Exception exception)
{
//wyjątek z zewnętrznej funkcji
HardwareContext.Status = VirtualMachineState.Exception;
Throw.ObslugaRzuconegoWyjatku(MethodContext.WirtualnaMaszyna, exception);
return;
}
if (method is MethodInfo methodInfo)
{
if (methodInfo.ReturnType == typeof(void))
{
//nie zwracam wyniku
}
else
{
MethodContext.PushObject(ret);
}
}
MethodContext.WykonajNastepnaInstrukcje();
}
else
{
//interpretowanie
//tworzę nową metodę i wrzucam ją na stos wykonania
var m = new MethodState(method, MethodContext.WirtualnaMaszyna, instance);
m.WczytajInstrukcje();
MethodContext = m;
var iloscArgumentow = method.GetParameters().Count();
if (method.IsStatic == false)
{
MethodContext.PushObject(instance);
iloscArgumentow += 1;
}
foreach (var parameter in parameters)
{
MethodContext.PushObject(parameter);
}
MethodContext.WczytajLokalneArgumenty(iloscArgumentow);
//wrzucam na stos wykonania nową metodę
HardwareContext.PushAktualnaMetode(MethodContext);
}
}
}
public BotDbContextAdapter(HardwareContext dbContext)
{
_dbContext = dbContext;
}
public MemberController(TransactionContext transactionContext, HardwareContext hardwareContext)
{
m_transactionContext = transactionContext;
m_hardwareContext = hardwareContext;
}
