async Task HandleConnection(TestContext ctx, ICommonConnection connection, Task readTask, Task writeTask, CancellationToken cancellationToken)
{
var t1 = readTask.ContinueWith(t => {
LogDebug(ctx, 1, "HandleConnection - read done", connection, t.Status, t.IsFaulted, t.IsCanceled);
if (t.IsFaulted || t.IsCanceled)
{
Dispose();
}
});
var t2 = writeTask.ContinueWith(t => {
LogDebug(ctx, 1, "HandleConnection - write done", connection, t.Status, t.IsFaulted, t.IsCanceled);
if (t.IsFaulted || t.IsCanceled)
{
Dispose();
}
});
LogDebug(ctx, 1, "HandleConnection", connection);
await Task.WhenAll(readTask, writeTask, t1, t2);
cancellationToken.ThrowIfCancellationRequested();
LogDebug(ctx, 1, "HandleConnection done", connection);
}
public Task <StatusCompletion.PayloadData> Status(ICommonConnection connection,
StatusCommand.PayloadData payload,
CancellationToken cancellation)
{
StatusCompletion.PayloadData.CommonClass common = new StatusCompletion.PayloadData.CommonClass(
StatusCompletion.PayloadData.CommonClass.DeviceEnum.Online,
new List <string>(),
new StatusCompletion.PayloadData.CommonClass.GuideLightsClass(
StatusCompletion.PayloadData.CommonClass.GuideLightsClass.FlashRateEnum.Off,
StatusCompletion.PayloadData.CommonClass.GuideLightsClass.ColorEnum.Green,
StatusCompletion.PayloadData.CommonClass.GuideLightsClass.DirectionEnum.Off),
StatusCompletion.PayloadData.CommonClass.DevicePositionEnum.Inposition,
0,
StatusCompletion.PayloadData.CommonClass.AntiFraudModuleEnum.Ok);
StatusCompletion.PayloadData.CardReaderClass cardReader = new StatusCompletion.PayloadData.CardReaderClass(
MediaStatus,
StatusCompletion.PayloadData.CardReaderClass.RetainBinEnum.Ok,
StatusCompletion.PayloadData.CardReaderClass.SecurityEnum.NotSupported,
0,
StatusCompletion.PayloadData.CardReaderClass.ChipPowerEnum.PoweredOff,
StatusCompletion.PayloadData.CardReaderClass.ChipModuleEnum.Ok,
StatusCompletion.PayloadData.CardReaderClass.MagWriteModuleEnum.Ok,
StatusCompletion.PayloadData.CardReaderClass.FrontImageModuleEnum.Ok,
StatusCompletion.PayloadData.CardReaderClass.BackImageModuleEnum.Ok,
new List <string>());
return(Task.FromResult(new StatusCompletion.PayloadData(StatusCompletion.PayloadData.CompletionCodeEnum.Success,
"ok",
common,
cardReader)));
}
protected async Task WriteBlob(TestContext ctx, ICommonConnection connection, string type, byte[] blob, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
LogDebug(ctx, 2, "WriteBlob", connection, type);
await connection.Stream.WriteAsync(blob, 0, blob.Length, cancellationToken);
LogDebug(ctx, 2, "WriteBlob done", connection, type);
}
protected async Task WriteBlob(TestContext ctx, ICommonConnection connection, HandshakeInstrumentType type, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
LogDebug(ctx, 2, "WriteBlob", connection, type);
var blob = Instrumentation.GetTextBuffer(type);
await connection.Stream.WriteAsync(blob.Buffer, blob.Offset, blob.Size, cancellationToken);
LogDebug(ctx, 2, "WriteBlob done", connection, type);
}
protected async Task ExpectBlob(TestContext ctx, ICommonConnection connection, HandshakeInstrumentType type, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
LogDebug(ctx, 2, "ExpectBlob", connection, type);
var buffer = new byte [4096];
var blob = Instrumentation.GetTextBuffer(type);
var ret = await connection.Stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
LogDebug(ctx, 2, "ExpectBlob #1", connection, type, ret);
if (ctx.Expect(ret, Is.GreaterThan(0), "read success"))
{
var result = new BufferOffsetSize(buffer, 0, ret);
ctx.Expect(result, new IsEqualBlob(blob), "blob");
}
LogDebug(ctx, 2, "ExpectBlob done", connection, type);
}
protected async Task ExpectBlob(TestContext ctx, ICommonConnection connection, string type, byte[] blob, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
LogDebug(ctx, 2, "ExpectBlob", connection, type);
var buffer = new byte [4096];
var ret = await connection.Stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
LogDebug(ctx, 2, "ExpectBlob #1", connection, type, ret);
if (ctx.Expect(ret, Is.GreaterThan(0), "read success"))
{
var result = new byte [ret];
Buffer.BlockCopy(buffer, 0, result, 0, ret);
ctx.Expect(result, new IsEqualBlob(blob), "blob");
}
LogDebug(ctx, 2, "ExpectBlob done", connection, type);
}
public Combo(ICommonConnection connection)
{
_connection = connection;
}
public CommonConnectionHandler(ICommonConnection connection)
{
Connection = connection;
}
public Task <SetGuidanceLightCompletion.PayloadData> SetGuidanceLight(ICommonConnection connection,
SetGuidanceLightCommand.PayloadData payload,
CancellationToken cancellation) => throw new System.NotImplementedException();
public ProductPriceListRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public Task <SynchronizeCommandCompletion.PayloadData> SynchronizeCommand(ICommonConnection connection,
SynchronizeCommandCommand.PayloadData payload,
CancellationToken cancellation) => throw new System.NotImplementedException();
public LocationRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public OrderHistoryRepository(DbContext db, ICommonConnection connection, IMapper mapper) : base(db)
{
_connection = connection;
_mapper = mapper;
}
public Task <GetTransactionStateCompletion.PayloadData> GetTransactionState(ICommonConnection connection,
GetTransactionStateCommand.PayloadData payload,
CancellationToken cancellation) => throw new System.NotImplementedException();
public Grid(ICommonConnection connection)
{
_connection = connection;
}
public UnitOfWork(DbContext context, ICommonConnection connection)
{
_context = context;
_connection = connection;
}
async Task HandleConnection (TestContext ctx, ICommonConnection connection, Task readTask, Task writeTask, CancellationToken cancellationToken)
{
var t1 = readTask.ContinueWith (t => {
LogDebug (ctx, 1, "HandleConnection - read done", connection, t.Status, t.IsFaulted, t.IsCanceled);
if (t.IsFaulted || t.IsCanceled)
Dispose ();
});
var t2 = writeTask.ContinueWith (t => {
LogDebug (ctx, 1, "HandleConnection - write done", connection, t.Status, t.IsFaulted, t.IsCanceled);
if (t.IsFaulted || t.IsCanceled)
Dispose ();
});
LogDebug (ctx, 1, "HandleConnection", connection);
await Task.WhenAll (readTask, writeTask, t1, t2);
cancellationToken.ThrowIfCancellationRequested ();
LogDebug (ctx, 1, "HandleConnection done", connection);
}
protected async Task WriteBlob (TestContext ctx, ICommonConnection connection, HandshakeInstrumentType type, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested ();
LogDebug (ctx, 2, "WriteBlob", connection, type);
var blob = Instrumentation.GetTextBuffer (type);
await connection.Stream.WriteAsync (blob.Buffer, blob.Offset, blob.Size, cancellationToken);
LogDebug (ctx, 2, "WriteBlob done", connection, type);
}
protected async Task ExpectBlob (TestContext ctx, ICommonConnection connection, HandshakeInstrumentType type, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested ();
LogDebug (ctx, 2, "ExpectBlob", connection, type);
var buffer = new byte [4096];
var blob = Instrumentation.GetTextBuffer (type);
var ret = await connection.Stream.ReadAsync (buffer, 0, buffer.Length, cancellationToken);
LogDebug (ctx, 2, "ExpectBlob #1", connection, type, ret);
if (ctx.Expect (ret, Is.GreaterThan (0), "read success")) {
var result = new BufferOffsetSize (buffer, 0, ret);
ctx.Expect (result, new IsEqualBlob (blob), "blob");
}
LogDebug (ctx, 2, "ExpectBlob done", connection, type);
}
public DealerTypeRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public OrderPaymentHistoryRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
protected Task WriteBlob(TestContext ctx, ICommonConnection connection, HandshakeInstrumentType type, CancellationToken cancellationToken)
{
return(WriteBlob(ctx, connection, type.ToString(), Instrumentation.GetTextBuffer(type), cancellationToken));
}
public AutoComplete(ICommonConnection connection)
{
_connection = connection;
}
public TallySearchRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public ProductInformationRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public Scheduler(ICommonConnection connection)
{
_connection = connection;
}
public Task <PowerSaveControlCompletion.PayloadData> PowerSaveControl(ICommonConnection connection,
PowerSaveControlCommand.PayloadData payload,
CancellationToken cancellation) => throw new System.NotImplementedException();
public AddDateProductPriceApproveRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public Diagram(ICommonConnection connection)
{
_connection = connection;
}
public ProductPriceServices(IProductPriceRepository repository, IUnitOfWork unitOfWork, ICommonConnection connection)
{
_repository = repository;
_connection = connection;
_unitOfWork = unitOfWork;
}
public MultiSelect(ICommonConnection connection)
{
_connection = connection;
}
public ProductDetailsRepository(DbContext db, ICommonConnection connection) : base(db)
{
_connection = connection;
}
public Data(ICommonConnection connection)
{
_connection = connection;
}
