public async Task AnyContractManyEventAsync()
{
var erc20transferEventLogs = new List <EventLog <TransferEvent> >();
var erc721TransferEventLogs = new List <EventLog <Erc721TransferEvent> >();
var web3 = new Web3.Web3(TestConfiguration.BlockchainUrls.Infura.Rinkeby);
var erc20TransferHandler = new EventLogProcessorHandler <TransferEvent>(
eventLog => erc20transferEventLogs.Add(eventLog));
var erc721TransferHandler = new EventLogProcessorHandler <Erc721TransferEvent>(
eventLog => erc721TransferEventLogs.Add(eventLog));
var processingHandlers = new ProcessorHandler <FilterLog>[] {
erc20TransferHandler, erc721TransferHandler
};
//create our processor to retrieve transfers
//restrict the processor to Transfers for a specific contract address
var processor = web3.Processing.Logs.CreateProcessor(processingHandlers);
//if we need to stop the processor mid execution - call cancel on the token
var cancellationToken = new CancellationToken();
//crawl the required block range
await processor.ExecuteAsync(
toBlockNumber : new BigInteger(3146690),
cancellationToken : cancellationToken,
startAtBlockNumberIfNotProcessed : new BigInteger(3146684));
Assert.Equal(13, erc20transferEventLogs.Count);
Assert.Equal(3, erc721TransferEventLogs.Count);
}
public static async Task Main(string[] args)
{
var erc20transferEventLogs = new List <EventLog <TransferEvent> >();
var erc721TransferEventLogs = new List <EventLog <Erc721TransferEvent> >();
var web3 = new Web3("https://rinkeby.infura.io/v3/7238211010344719ad14a89db874158c");
var erc20TransferHandler = new EventLogProcessorHandler <TransferEvent>(
eventLog => erc20transferEventLogs.Add(eventLog));
var erc721TransferHandler = new EventLogProcessorHandler <Erc721TransferEvent>(
eventLog => erc721TransferEventLogs.Add(eventLog));
var processingHandlers = new ProcessorHandler <FilterLog>[] {
erc20TransferHandler, erc721TransferHandler
};
//create our processor to retrieve transfers
//restrict the processor to Transfers for a specific contract address
var processor = web3.Processing.Logs.CreateProcessor(processingHandlers);
//if we need to stop the processor mid execution - call cancel on the token
var cancellationToken = new CancellationToken();
//crawl the required block range
await processor.ExecuteAsync(
toBlockNumber : new BigInteger(3146690),
cancellationToken : cancellationToken,
startAtBlockNumberIfNotProcessed : new BigInteger(3146684));
Console.WriteLine($"Expected 13 ERC20 transfers. Logs found: {erc20transferEventLogs.Count}.");
Console.WriteLine($"Expected 3 ERC721 transfers. Logs found: {erc721TransferEventLogs.Count}.");
}
public LogOrchestratorTests()
{
_web3Mock = new Web3Mock();
_logsHandled = new List <FilterLog>();
_logHandler = new ProcessorHandler <FilterLog>((filterLog) => { _logsHandled.Add(filterLog); return(Task.CompletedTask); });
_logOrchestrator = new LogOrchestrator(_web3Mock.EthApiContractServiceMock.Object, new [] { _logHandler }, null, 100, 1);
}
//single processor
public BlockchainProcessor CreateProcessor(
ProcessorHandler <FilterLog> logProcessor,
uint minimumBlockConfirmations,
NewFilterInput filter = null,
IBlockProgressRepository blockProgressRepository = null,
ILog log = null) => CreateProcessor(new[] { logProcessor }, minimumBlockConfirmations, filter, blockProgressRepository, log);
public BlockchainProcessor CreateProcessorForContracts <TEventDTO>(
ProcessorHandler <FilterLog> logProcessor,
string[] contractAddresses,
uint minimumBlockConfirmations,
IBlockProgressRepository blockProgressRepository = null,
ILog log = null) where TEventDTO : class =>
CreateProcessor(new[] { logProcessor }, minimumBlockConfirmations, new FilterInputBuilder <TEventDTO>().Build(contractAddresses),
blockProgressRepository, log);
public Task <IProcessorHandler <FilterLog> > GetLogRepositoryHandlerAsync(string tablePrefix)
{
var cloudTableSetup = GetCloudTableSetup(tablePrefix);
var repo = cloudTableSetup.CreateTransactionLogRepository();
IProcessorHandler <FilterLog> handler = new ProcessorHandler <FilterLog>(
async(log) => await repo.UpsertAsync(new FilterLogVO(null, null, log)));
return(Task.FromResult(handler));
}
public void Test1()
{
ProcessorHandler ph = new ProcessorHandler();
Assert.AreEqual(true, ph.IsEmpty);
Assert.AreEqual(0, ph.Count);
bool bex = false;
try
{
ProcessorContainer unused = ph.Processors;
}
catch (Exception ex)
{
Assert.AreEqual(typeof(Exception), ex.GetType());
Assert.AreEqual($"{nameof(ProcessorHandler)}: Список карт пуст.", ex.Message);
bex = true;
}
Assert.AreEqual(true, bex);
ph.Add(new Processor(new[] { new SignValue(2) }, "A"));
Assert.AreEqual(false, ph.IsEmpty);
Assert.AreEqual(1, ph.Count);
ph.AddRange(new[] { new Processor(new[] { new SignValue(3) }, "b"), new Processor(new[] { new SignValue(4) }, "C") });
Assert.AreEqual(false, ph.IsEmpty);
Assert.AreEqual(3, ph.Count);
ProcessorContainer procs = ph.Processors;
Assert.AreNotEqual(null, procs);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(3, procs.Count);
string str = ph.ToString();
const string myStr = "AbC";
Assert.AreEqual(myStr, str);
HashSet <char> chs = ph.ToHashSet();
Assert.AreNotEqual(null, chs);
HashSet <char> chj = new HashSet <char>(myStr);
Assert.AreNotEqual(null, chj);
Assert.AreEqual(true, chs.SetEquals(chj));
}
static List <Processor> CheckProcessorHandler1(ProcessorHandler ph)
{
List <Processor> procs = new List <Processor>(ph.Processors.ToArray());
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(1, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual("A", ph.ToString());
return(procs);
}
static void CheckProcessorHandler2(ProcessorHandler ph)
{
Assert.AreNotEqual(null, ph);
ProcessorContainer procs = new ProcessorContainer(ph.Processors.ToArray());
Assert.AreNotEqual(null, procs);
Assert.AreEqual(procs.Width, 1);
Assert.AreEqual(procs.Height, 1);
Assert.AreEqual(3, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual("ABC", ph.ToString());
}
public async Task ManyContractsMultipleEvents()
{
const string ERC20_QUEUE_NAME = "many-contract-multi-event-erc20";
const string APPROVAL_QUEUE_NAME = "many-contract-multi-event-approval";
var azureQueueFactory = new AzureStorageQueueFactory(_azureConnectionString);
try
{
var erc20Queue = await azureQueueFactory.GetOrCreateQueueAsync(ERC20_QUEUE_NAME);
var approvalQueue = await azureQueueFactory.GetOrCreateQueueAsync(APPROVAL_QUEUE_NAME);
var erc20TransferProcessor = new EventLogProcessorHandler <TransferEventDTO>(transfer => erc20Queue.AddMessageAsync(transfer));
var approvalProcessor = new EventLogProcessorHandler <ApprovalEventDTO>(approval => approvalQueue.AddMessageAsync(approval));
var logProcessors = new ProcessorHandler <FilterLog>[] { erc20TransferProcessor, approvalProcessor };
var contractAddresses = new[] { "0x9EDCb9A9c4d34b5d6A082c86cb4f117A1394F831", "0xafbfefa496ae205cf4e002dee11517e6d6da3ef6" };
var contractFilter = new NewFilterInput {
Address = contractAddresses
};
var logProcessor = _web3.Processing.Logs.CreateProcessor(logProcessors, filter: contractFilter);
//if we need to stop the processor mid execution - call cancel on the token
var cancellationTokenSource = new CancellationTokenSource();
//crawl the required block range
await logProcessor.ExecuteAsync(
toBlockNumber : 3621716,
cancellationToken : cancellationTokenSource.Token,
startAtBlockNumberIfNotProcessed : 3621715);
Assert.Equal(2, await erc20Queue.GetApproxMessageCountAsync());
Assert.Equal(1, await approvalQueue.GetApproxMessageCountAsync());
}
finally
{
await azureQueueFactory.DeleteQueueAsync(ERC20_QUEUE_NAME);
await azureQueueFactory.DeleteQueueAsync(APPROVAL_QUEUE_NAME);
}
}
/// <summary>
/// Processes the message using mapped message handlers.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="cancellation">The cancellation.</param>
/// <returns>
/// <see langword="true" /> if message has been processed, <see langword="false" /> otherwise.
/// </returns>
public async ValueTask <bool> ProcessMessageAsync(INetworkMessage message, CancellationToken cancellation)
{
if (!_mapping.TryGetValue(message.GetType(), out List <ProcessorHandler>?handlers))
{
return(false);
}
for (int i = 0; i < handlers.Count; i++)
{
ProcessorHandler handler = handlers[i];
if (handler.processor.CanReceiveMessages)
{
// when an handler return false, mean it doesn't want other handlers to continue parsing the message
if (await handler.InvokeAsync(message, cancellation).ConfigureAwait(false))
{
break;
}
}
}
return(true);
}
public static async Task Main(string[] args)
{
var erc20transferEventLogs = new List <EventLog <TransferEvent> >();
var approvalEventLogs = new List <EventLog <ApprovalEventDTO> >();
var web3 = new Web3("https://rinkeby.infura.io/v3/7238211010344719ad14a89db874158c");
var erc20TransferHandler = new EventLogProcessorHandler <TransferEvent>(
eventLog => erc20transferEventLogs.Add(eventLog));
var erc721TransferHandler = new EventLogProcessorHandler <ApprovalEventDTO>(
eventLog => approvalEventLogs.Add(eventLog));
var processingHandlers = new ProcessorHandler <FilterLog>[] {
erc20TransferHandler, erc721TransferHandler
};
var contractFilter = new NewFilterInput {
Address = new [] { "0x9EDCb9A9c4d34b5d6A082c86cb4f117A1394F831" }
};
//create our processor to retrieve transfers
//restrict the processor to Transfers for a specific contract address
var processor = web3.Processing.Logs.CreateProcessor(
logProcessors: processingHandlers, filter: contractFilter);
//if we need to stop the processor mid execution - call cancel on the token
var cancellationToken = new CancellationToken();
//crawl the required block range
await processor.ExecuteAsync(
toBlockNumber : new BigInteger(3621716),
cancellationToken : cancellationToken,
startAtBlockNumberIfNotProcessed : new BigInteger(3621715));
Console.WriteLine($"Expected 2 ERC20 transfers. Logs found: {erc20transferEventLogs.Count}.");
Console.WriteLine($"Expected 1 Approval. Logs found: {approvalEventLogs.Count}.");
}
public async Task AnyContractMultipleEvents()
{
const string ERC20_QUEUE_NAME = "any-contract-one-event-erc20";
const string ERC721_QUEUE_NAME = "any-contract-one-event-erc721";
var azureQueueFactory = new AzureStorageQueueFactory(_azureConnectionString);
try
{
var erc20Queue = await azureQueueFactory.GetOrCreateQueueAsync(ERC20_QUEUE_NAME);
var erc721Queue = await azureQueueFactory.GetOrCreateQueueAsync(ERC721_QUEUE_NAME);
var erc20TransferProcessor = new EventLogProcessorHandler <TransferEventDTO>(transfer => erc20Queue.AddMessageAsync(transfer));
var erc721TransferProcessor = new EventLogProcessorHandler <Erc721TransferEvent>(transfer => erc721Queue.AddMessageAsync(transfer));
var logProcessors = new ProcessorHandler <FilterLog>[] { erc20TransferProcessor, erc721TransferProcessor };
var logProcessor = _web3.Processing.Logs.CreateProcessor(logProcessors);
//if we need to stop the processor mid execution - call cancel on the token
var cancellationTokenSource = new CancellationTokenSource();
//crawl the required block range
await logProcessor.ExecuteAsync(
toBlockNumber : 3146690,
cancellationToken : cancellationTokenSource.Token,
startAtBlockNumberIfNotProcessed : 3146684);
Assert.Equal(13, await erc20Queue.GetApproxMessageCountAsync());
Assert.Equal(3, await erc721Queue.GetApproxMessageCountAsync());
}
finally
{
await azureQueueFactory.DeleteQueueAsync(ERC20_QUEUE_NAME);
await azureQueueFactory.DeleteQueueAsync(ERC721_QUEUE_NAME);
}
}
public void PHTestException_7()
{
ProcessorHandler.ChangeProcessorTag(new Processor(new[] { SignValue.MaxValue }, "mmm"), " ");
}
public async Task ExecuteAsync(ILogger logger)
{
if (!_config.Enabled)
{
logger.LogInformation($"{nameof(ProcessPurchaseOrderEventLogs)} is not enabled - see app settings");
return;
}
const int RequestRetryWeight = 0; // see below for retry algorithm
var web3 = new Web3.Web3(_eshopConfiguration.EthereumRpcUrl);
var walletBuyerService = new WalletBuyerService(web3, _eshopConfiguration.BuyerWalletAddress);
var purchasingContractAddress = await walletBuyerService.PurchasingQueryAsync();
var filter = new NewFilterInput {
Address = new[] { purchasingContractAddress }
};
ILog log = logger.ToILog();
EventLogProcessorHandler <PurchaseOrderCreatedLogEventDTO> poCreatedHandler =
CreatePurchaseOrderCreatedHandler(logger);
var logProcessorHandlers = new ProcessorHandler <FilterLog>[]
{ poCreatedHandler };
IBlockchainProcessingOrchestrator orchestrator = new LogOrchestrator(
ethApi: web3.Eth,
logProcessors: logProcessorHandlers,
filterInput: filter,
defaultNumberOfBlocksPerRequest: (int)_config.NumberOfBlocksPerBatch,
retryWeight: RequestRetryWeight);
IWaitStrategy waitForBlockConfirmationsStrategy = new WaitStrategy();
ILastConfirmedBlockNumberService lastConfirmedBlockNumberService =
new LastConfirmedBlockNumberService(
web3.Eth.Blocks.GetBlockNumber,
waitForBlockConfirmationsStrategy,
_config.MinimumBlockConfirmations,
log);
var processor = new BlockchainProcessor(
orchestrator, BlockProgressRepository, lastConfirmedBlockNumberService);
var cancellationToken = new CancellationTokenSource(_config.TimeoutMs);
var currentBlockOnChain = await web3.Eth.Blocks.GetBlockNumber.SendRequestAsync();
var blockToProcessTo = currentBlockOnChain.Value - _config.MinimumBlockConfirmations;
var lastBlockProcessed = await BlockProgressRepository.GetLastBlockNumberProcessedAsync();
var minStartingBlock = _config.GetMinimumStartingBlock();
logger.LogInformation(
$"Processing logs. To Block: {blockToProcessTo}, Last Block Processed: {lastBlockProcessed ?? 0}, Min Block: {minStartingBlock}");
await processor.ExecuteAsync(
toBlockNumber : blockToProcessTo,
cancellationToken : cancellationToken.Token,
startAtBlockNumberIfNotProcessed : minStartingBlock);
}
public void Execute(ITransactionScopeContext transactionScopeContext)
{
ProcessorHandler.Execute(this, transactionScopeContext);
}
public static async Task Main(string[] args)
{
// the number of blocks in a range to process in one batch
const int DefaultBlocksPerBatch = 10;
const int RequestRetryWeight = 0; // see below for retry algorithm
// ensures the processor does not process blocks considered unconfirmed
const int MinimumBlockConfirmations = 6;
// somewhere to put the logs
var logs = new List <FilterLog>();
// the web3 object dictates the target network
// it provides the basis for processing
var web3 = new Web3("https://rinkeby.infura.io/v3/7238211010344719ad14a89db874158c");
// only logs matching this filter will be processed
// in this example we are targetting logs from a specific contract
var filter = new NewFilterInput()
{
Address = new[] { "0x9edcb9a9c4d34b5d6a082c86cb4f117a1394f831" }
};
// for logs matching the filter apply our handler
// this handler has an action which be invoked if the criteria matches
// async overloads for the action and criteria are also available
// this handler is for any log
// for event specific handlers - there is EventLogProcessorHandler<TEventDto>
var logProcessorHandler = new ProcessorHandler <FilterLog>(
action: (log) => logs.Add(log),
criteria: (log) => log.Removed == false);
// the processor accepts multiple handlers
// add our single handler to a list
IEnumerable <ProcessorHandler <FilterLog> > logProcessorHandlers = new ProcessorHandler <FilterLog>[] { logProcessorHandler };
// the processor accepts an optional ILog
// replace this with your own Common.Logging.Log implementation
ILog logger = null;
/*
* === Internal Log Request Retry Algorithm ===
* If requests to retrieve logs from the client fails, subsequent requests will be retried based on this algorithm
* It's aim is to throttle the number of blocks in the request range and avoid errors
* The retry weight proportionately restricts the reduction in block range per retry
* (pseudo code)
* nextBlockRangeSize = numberOfBlocksPerRequest / (retryRequestNumber + 1) + (_retryWeight * retryRequestNumber);
*/
// load the components into a LogOrchestrator
IBlockchainProcessingOrchestrator orchestrator = new LogOrchestrator(
ethApi: web3.Eth,
logProcessors: logProcessorHandlers,
filterInput: filter,
defaultNumberOfBlocksPerRequest: DefaultBlocksPerBatch,
retryWeight: RequestRetryWeight);
// create a progress repository
// can dictate the starting block (depending on the execution arguments)
// stores the last block progresssed
// you can write your own or Nethereum provides multiple implementations
// https://github.com/Nethereum/Nethereum.BlockchainStorage/
IBlockProgressRepository progressRepository = new InMemoryBlockchainProgressRepository();
// this strategy is applied while waiting for block confirmations
// it will apply a wait to allow the chain to add new blocks
// the wait duration is dependant on the number of retries
// feel free to implement your own
IWaitStrategy waitForBlockConfirmationsStrategy = new WaitStrategy();
// this retrieves the current block on the chain (the most recent block)
// it determines the next block to process ensuring it is within the min block confirmations
// in the scenario where processing is up to date with the chain (i.e. processing very recent blocks)
// it will apply a wait until the minimum block confirmations is met
ILastConfirmedBlockNumberService lastConfirmedBlockNumberService =
new LastConfirmedBlockNumberService(
web3.Eth.Blocks.GetBlockNumber, waitForBlockConfirmationsStrategy, MinimumBlockConfirmations);
// instantiate the main processor
var processor = new BlockchainProcessor(
orchestrator, progressRepository, lastConfirmedBlockNumberService, logger);
// if we need to stop the processor mid execution - call cancel on the token source
var cancellationToken = new CancellationTokenSource();
//crawl the required block range
await processor.ExecuteAsync(
toBlockNumber : new BigInteger(3146690),
cancellationToken : cancellationToken.Token,
startAtBlockNumberIfNotProcessed : new BigInteger(3146684));
Console.WriteLine($"Expected 4 logs. Logs found: {logs.Count}.");
}
public void PHTest()
{
ProcessorHandler ph = new ProcessorHandler();
Assert.AreEqual(string.Empty, ph.ToString());
Assert.AreEqual(0, ph.Processors.ToArray().Length);
ph.Add(new Processor(new[] { new SignValue(2) }, "A"));
List <Processor> procs = CheckProcessorHandler1(ph);
procs.Add(new Processor(new[] { new SignValue(2000) }, "w"));
CheckProcessorHandler1(ph);
ph.Add(new Processor(new[] { new SignValue(3) }, "b"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(2, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual("AB", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(4) }, "C"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(2) }, "A"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(3) }, "b"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(4) }, "C"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(2) }, "A1"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(3) }, "b1"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(4) }, "C1"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(2) }, "a1"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(3) }, "B1"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(4) }, "c1"));
CheckProcessorHandler2(ph);
ph.Add(new Processor(new[] { new SignValue(13) }, "b1"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(4, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual("ABCB", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(14) }, "B1"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(5, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual("ABCBB", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(15) }, "B"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(6, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual(new SignValue(15), procs[5][0, 0]);
Assert.AreEqual("B0", procs[5].Tag);
Assert.AreEqual("ABCBBB", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(16) }, "b"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(7, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual(new SignValue(15), procs[5][0, 0]);
Assert.AreEqual("B0", procs[5].Tag);
Assert.AreEqual(new SignValue(16), procs[6][0, 0]);
Assert.AreEqual("b00", procs[6].Tag);
Assert.AreEqual("ABCBBBB", ph.ToString());
bool bex = false;
try
{
SignValue[,] prc = new SignValue[2, 1];
prc[0, 0] = new SignValue(16);
prc[1, 0] = new SignValue(100);
ph.Add(new Processor(prc, "b"));
}
catch (Exception ex)
{
Assert.AreEqual(typeof(ArgumentException), ex.GetType());
Assert.AreEqual("Добавляемая карта отличается по размерам от первой карты, добавленной в коллекцию. Требуется: 1, 1. Фактически: 2, 1.", ex.Message);
bex = true;
}
Assert.AreEqual(true, bex);
bex = false;
try
{
SignValue[,] prc = new SignValue[1, 2];
prc[0, 0] = new SignValue(16);
prc[0, 1] = new SignValue(100);
ph.Add(new Processor(prc, "b"));
}
catch (Exception ex)
{
Assert.AreEqual(typeof(ArgumentException), ex.GetType());
Assert.AreEqual("Добавляемая карта отличается по размерам от первой карты, добавленной в коллекцию. Требуется: 1, 1. Фактически: 1, 2.", ex.Message);
bex = true;
}
Assert.AreEqual(true, bex);
ph.Add(new Processor(new[] { new SignValue(3) }, "r"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(8, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual(new SignValue(15), procs[5][0, 0]);
Assert.AreEqual("B0", procs[5].Tag);
Assert.AreEqual(new SignValue(16), procs[6][0, 0]);
Assert.AreEqual("b00", procs[6].Tag);
Assert.AreEqual(new SignValue(3), procs[7][0, 0]);
Assert.AreEqual("r", procs[7].Tag);
Assert.AreEqual("ABCBBBBR", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(2) }, "v1"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(9, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual(new SignValue(15), procs[5][0, 0]);
Assert.AreEqual("B0", procs[5].Tag);
Assert.AreEqual(new SignValue(16), procs[6][0, 0]);
Assert.AreEqual("b00", procs[6].Tag);
Assert.AreEqual(new SignValue(3), procs[7][0, 0]);
Assert.AreEqual("r", procs[7].Tag);
Assert.AreEqual(new SignValue(2), procs[8][0, 0]);
Assert.AreEqual("v1", procs[8].Tag);
Assert.AreEqual("ABCBBBBRV", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(8418982) }, "q"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(10, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual(new SignValue(15), procs[5][0, 0]);
Assert.AreEqual("B0", procs[5].Tag);
Assert.AreEqual(new SignValue(16), procs[6][0, 0]);
Assert.AreEqual("b00", procs[6].Tag);
Assert.AreEqual(new SignValue(3), procs[7][0, 0]);
Assert.AreEqual("r", procs[7].Tag);
Assert.AreEqual(new SignValue(2), procs[8][0, 0]);
Assert.AreEqual("v1", procs[8].Tag);
Assert.AreEqual(new SignValue(8418982), procs[9][0, 0]);
Assert.AreEqual("q", procs[9].Tag);
Assert.AreEqual("ABCBBBBRVQ", ph.ToString());
ph.Add(new Processor(new[] { new SignValue(12451893) }, "q"));
procs = ph.Processors.ToList();
Assert.AreNotEqual(null, procs);
CheckSize(procs);
Assert.AreEqual(11, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(new SignValue(13), procs[3][0, 0]);
Assert.AreEqual("b1", procs[3].Tag);
Assert.AreEqual(new SignValue(14), procs[4][0, 0]);
Assert.AreEqual("B10", procs[4].Tag);
Assert.AreEqual(new SignValue(15), procs[5][0, 0]);
Assert.AreEqual("B0", procs[5].Tag);
Assert.AreEqual(new SignValue(16), procs[6][0, 0]);
Assert.AreEqual("b00", procs[6].Tag);
Assert.AreEqual(new SignValue(3), procs[7][0, 0]);
Assert.AreEqual("r", procs[7].Tag);
Assert.AreEqual(new SignValue(2), procs[8][0, 0]);
Assert.AreEqual("v1", procs[8].Tag);
Assert.AreEqual(new SignValue(8418982), procs[9][0, 0]);
Assert.AreEqual("q", procs[9].Tag);
Assert.AreEqual(new SignValue(12451893), procs[10][0, 0]);
Assert.AreEqual("q0", procs[10].Tag);
Assert.AreEqual("ABCBBBBRVQQ", ph.ToString());
Processor renameProcessor2 = ProcessorHandler.ChangeProcessorTag(new Processor(new[] { SignValue.MaxValue }, "mmM"), "zZz");
Assert.AreNotEqual(null, renameProcessor2);
Assert.AreEqual("zZz", renameProcessor2.Tag);
Assert.AreEqual(SignValue.MaxValue, renameProcessor2[0, 0]);
Assert.AreEqual(1, renameProcessor2.Width);
Assert.AreEqual(1, renameProcessor2.Height);
Processor renameProcessor3 = ProcessorHandler.ChangeProcessorTag(new Processor(new[] { SignValue.MaxValue }, "mmM"), "mmM");
Assert.AreNotEqual(null, renameProcessor3);
Assert.AreEqual("mmM", renameProcessor3.Tag);
Assert.AreEqual(SignValue.MaxValue, renameProcessor3[0, 0]);
Assert.AreEqual(1, renameProcessor3.Width);
Assert.AreEqual(1, renameProcessor3.Height);
}
public void PHTestException_11()
{
ProcessorHandler.ChangeProcessorTag(null, "a");
}
public void PHTestException_9()
{
ProcessorHandler.ChangeProcessorTag(null, null);
}
public void PHTestException_8()
{
ProcessorHandler.ChangeProcessorTag(null, string.Empty);
}
public void PHTestException_5()
{
ProcessorHandler.ChangeProcessorTag(new Processor(new[] { SignValue.MaxValue }, "mmm"), string.Empty);
}
