Smartesting pioneers intelligent testing with Yest, a visually intuitive Model-Based Testing (MBT) tool for precise test case design, and Gravity, an AI-driven Usage-Centric testing tool monitoring live production for insights on usage patterns, test gaps, and test case generation.

Smartesting

smarttesting

smart-doc is a tool for automatically generating Java API documentation. It creates documentation by analyzing interfaces and comments in the source code and supports a variety of document output formats, including Markdown, HTML5, OpenAPI 3.0, and more. The design goal of smart-doc is to simplify the document writing process, improve development efficiency, and ensure the accuracy and timeliness of the documentation. In the software development lifecycle, the automatic generation of API documentation and the performance testing of interfaces are key steps in improving development efficiency and ensuring product quality. With the addition of the ability to generate JMeter performance testing scripts in smart-doc version 3.0.1, developers can more conveniently accomplish these two tasks. This article will introduce how to use smart-doc and JMeter for effective performance testing. Generate JMeter Scripts Using smart-doc to generate JMeter performance test scripts can significantly reduce the time taken to write performance test scripts, thereby improving testing efficiency. The JMeter scripts that are automatically generated by smart-doc can be directly run in JMeter without the need for complex configuration and debugging, making performance testing much simpler and faster. First, ensure that the smart-doc-maven-plugin has been added to your project. Then, configure the relevant parameters of the smart-doc plugin in the pom.xml file of the project, for example: <plugin>
     <groupId>com.ly.smart-doc</groupId>
     <artifactId>smart-doc-maven-plugin</artifactId>
     <version>[latest version]</version>
     <configuration>
         <configFile>./src/main/resources/smart-doc.json</configFile>
         <projectName>${project.description}</projectName>
     </configuration>
</plugin> Run the command mvn -Dfile.encoding=UTF-8 smart-doc:jmeter. Smart-doc will scan the project source code, extract annotation information, and automatically generate the corresponding JMeter performance test scripts. Those who are not familiar with how to use it can refer to the official smart-doc documentation. Import Into JMeter Open JMeter, click "File" -> "Open", select the JMeter script file generated in the first step, and click the "Start" button. JMeter will then begin performing performance tests according to the script. Configure Prometheus Prometheus is an open-source monitoring and alerting tool for handling time-series data. We can use it to perform real-time monitoring during the JMeter stress testing process, thereby enhancing the observability of performance testing. Step 1: Install the JMeter Prometheus Plugin First, you need to install the Prometheus plugin in the lib/ext directory of JMeter. You can download the plugin from the JMeter Plugins Manager or the official website. It can also be downloaded from GitHub. For this instance, download the latest version 0.7.1 from GitHub. Note: JMeter's default listening IP address is 127.0.0.1, which, by default, will prevent Prometheus from connecting to the JMeter Prometheus listening port. Therefore, it is necessary to add prometheus.ip=0.0.0.0 in jmeter.properties. Step 2: Add Prometheus Listener Open JMeter, and add the Prometheus Listener to your test plan. This can be done by right-clicking on Test Plan-> Add -> Listener -> Prometheus Listener. The configuration of the listener can refer to the official settings, with reference as follows (smart-doc 3.0.4 supports configuring and adding Prometheus Listener generation): Step 3: Configure Prometheus Scrape In the configuration file of Prometheus (prometheus.yml), add a new scrape_config to fetch data from the JMeter Prometheus plugin. For example: scrape_configs:
  - job_name: 'jmeter'
    scrape_interval: 15s
    static_configs:
        - targets: ['<Your JMeter machine IP>:9270'] Here, <Your JMeter machine IP> is the IP address of the machine running the JMeter test, and 9270 is the default listening port for the JMeter Prometheus plugin. Step 4: Run the Test Plan For the purpose of easy verification in this article, the thread group is set to "infinite loop" during stress testing, which can be adjusted according to actual needs. After starting successfully, JMeter Prometheus will, by default, create a service on the local port 9270. Access the URL http://localhost:9270/metrics, and if you see the following content, it means it has been successful. Step 5: Start Prometheus After starting Prometheus, it will begin to fetch data from the JMeter Prometheus plugin. As shown in the following configuration, once successfully started, you can see the set targets in Prometheus. Step 6: Configure Grafana On the Grafana official website, find the prometheus-jmeter monitoring panel provided by the official site. Here, we select the template with the ID 14927 to import into Grafana. After clicking Load, select the Prometheus data source. Note: During testing, it was found that the original template 14927 had some errors. These were fixed during the writing process of this article. Import the corrected template downloaded from GitHub. After the template is successfully imported, we will be able to see the entire performance testing monitoring data in Grafana. To facilitate a rapid experience of the entire performance testing process, the smart-doc community has curated and provided a template that can be launched with a single command using docker-compose. For those who wish to experience it through Kubernetes deployment, AI tools can be utilized to directly convert the docker-compose template into a Kubernetes deployment template. The project for the experience also includes usage instructions. The example code for this article can be found here. The Assistance of Smart-Doc in JMeter Performance Testing The combination of smart-doc and JMeter for performance stress testing offers several advantages: Automation: smart-doc can automatically extract API information from the source code and generate JMeter performance test scripts without the need for manual writing, greatly improving efficiency. Precision: The JMeter performance test scripts generated by smart-doc are completely consistent with the API definitions in the source code, avoiding errors that may occur when manually writing scripts. Flexibility: smart-doc supports a variety of configuration options, allowing the generated JMeter scripts to be customized according to testing requirements. smart-doc will also continue to improve and optimize support for JMeter. Please stay tuned for the ongoing development of the smart-doc open-source project. Conclusion By combining smart-doc and JMeter, we can not only automate the generation of API documentation but also swiftly create performance test scripts and conduct stress testing. This automation tool significantly enhances development and testing efficiency while helping teams more easily maintain and optimize the performance of software systems. We hope this article has provided practical references for you to apply these tools more efficiently in your daily work. We also welcome everyone to continue to follow and support the smart-doc open-source community. In the future, we are exploring support for additional languages to assist more developers. smart-doc is a tool for automatically generating Java API documentation. It creates documentation by analyzing interfaces and comments in the source code and supports a variety of document output formats, including Markdown , HTML5 , OpenAPI 3.0 , and more. The design goal of smart-doc is to simplify the document writing process, improve development efficiency, and ensure the accuracy and timeliness of the documentation. smart-doc Java API Java API Markdown HTML5 , OpenAPI 3.0 , In the software development lifecycle, the automatic generation of API documentation and the performance testing of interfaces are key steps in improving development efficiency and ensuring product quality. With the addition of the ability to generate JMeter performance testing scripts in smart-doc version 3.0.1 , developers can more conveniently accomplish these two tasks. performance testing performance testing smart-doc 3.0.1 This article will introduce how to use smart-doc and JMeter for effective performance testing. Generate JMeter Scrip ts Generate JMeter ts Using smart-doc to generate JMeter performance test scripts can significantly reduce the time taken to write performance test scripts, thereby improving testing efficiency. The JMeter scripts that are automatically generated by smart-doc can be directly run in JMeter without the need for complex configuration and debugging, making performance testing much simpler and faster. smart-doc JMeter JMeter smart-doc First, ensure that the smart-doc-maven-plugin has been added to your project. Then, configure the relevant parameters of the smart-doc plugin in the pom.xml file of the project, for example: smart-doc-maven-plugin pom.xml <plugin>
     <groupId>com.ly.smart-doc</groupId>
     <artifactId>smart-doc-maven-plugin</artifactId>
     <version>[latest version]</version>
     <configuration>
         <configFile>./src/main/resources/smart-doc.json</configFile>
         <projectName>${project.description}</projectName>
     </configuration>
</plugin> <plugin>
     <groupId>com.ly.smart-doc</groupId>
     <artifactId>smart-doc-maven-plugin</artifactId>
     <version>[latest version]</version>
     <configuration>
         <configFile>./src/main/resources/smart-doc.json</configFile>
         <projectName>${project.description}</projectName>
     </configuration>
</plugin> Run the command mvn -Dfile.encoding=UTF-8 smart-doc:jmeter . Smart-doc will scan the project source code, extract annotation information, and automatically generate the corresponding JMeter performance test scripts. mvn -Dfile.encoding=UTF-8 smart-doc:jmeter Those who are not familiar with how to use it can refer to the official smart-doc documentation . smart-doc documentation smart-doc documentation Import Into JMeter Import Into JMeter Open JMeter, click " File " -> " Open ", select the JMeter script file generated in the first step, and click the " Start " button. JMeter will then begin performing performance tests according to the script. File Open Start Configure Prometheus Configure Prometheus Prometheus is an open-source monitoring and alerting tool for handling time-series data. We can use it to perform real-time monitoring during the JMeter stress testing process, thereby enhancing the observability of performance testing. Prometheus Prometheus Step 1: Install the JMeter Prometheus Plugin Step 1: Install the JMeter Prometheus Plugin First, you need to install the Prometheus plugin in the lib/ext directory of JMeter. You can download the plugin from the JMeter Plugins Manager or the official website . It can also be downloaded from GitHub . For this instance, download the latest version 0.7.1 from GitHub. lib/ext official website official website GitHub GitHub Note: JMeter's default listening IP address is 127.0.0.1, which, by default, will prevent Prometheus from connecting to the JMeter Prometheus listening port. Therefore, it is necessary to add prometheus.ip=0.0.0.0 in jmeter.properties. Note: JMeter's default listening IP address is 127.0.0.1 , which, by default, will prevent Prometheus from connecting to the JMeter Prometheus listening port. Therefore, it is necessary to add prometheus.ip=0.0.0.0 in jmeter.properties . Note: 127.0.0.1 prometheus.ip=0.0.0.0 jmeter.properties Step 2: Add Prometheus Listener Step 2: Add Prometheus Listener Open JMeter, and add the Prometheus Listener to your test plan. This can be done by right-clicking on Test Plan -> Add -> Listener -> Prometheus Listener . Test Plan Add Listener Prometheus Listener The configuration of the listener can refer to the official settings, with reference as follows ( smart-doc 3.0.4 supports configuring and adding Prometheus Listener generation): smart-doc 3.0.4 Step 3: Configure Prometheus Scrape Step 3: Configure Prometheus Scrape In the configuration file of Prometheus ( prometheus.yml ), add a new scrape_config to fetch data from the JMeter Prometheus plugin. For example: prometheus.yml scrape_config scrape_configs:
  - job_name: 'jmeter'
    scrape_interval: 15s
    static_configs:
        - targets: ['<Your JMeter machine IP>:9270'] scrape_configs:
  - job_name: 'jmeter'
    scrape_interval: 15s
    static_configs:
        - targets: ['<Your JMeter machine IP>:9270'] Here, <Your JMeter machine IP> is the IP address of the machine running the JMeter test, and 9270 is the default listening port for the JMeter Prometheus plugin. <Your JMeter machine IP> 9270 Step 4: Run the Test Plan Step 4: Run the Test Plan For the purpose of easy verification in this article, the thread group is set to " infinite loop " during stress testing, which can be adjusted according to actual needs. infinite loop After starting successfully, JMeter Prometheus will, by default, create a service on the local port 9270 . 9270 Access the URL http://localhost:9270/metrics, and if you see the following content, it means it has been successful. http://localhost:9270/metrics, http://localhost:9270/metrics , http://localhost:9270/metrics Step 5: Start Prometheus Step 5: Start Prometheus After starting Prometheus , it will begin to fetch data from the JMeter Prometheus plugin. As shown in the following configuration, once successfully started, you can see the set targets in Prometheus . Prometheus Prometheus Step 6: Configure Grafana Step 6: Configure Grafana On the Grafana official website, find the prometheus-jmeter monitoring panel provided by the official site. Here, we select the template with the ID 14927 to import into Grafana. Grafana 14927 After clicking Load , select the Prometheus data source. Load Prometheus Note: During testing, it was found that the original template 14927 had some errors. These were fixed during the writing process of this article. Import the corrected template downloaded from GitHub. Note: During testing, it was found that the original template 14927 had some errors. These were fixed during the writing process of this article. Import the corrected template downloaded from GitHub . Note: 14927 GitHub GitHub After the template is successfully imported, we will be able to see the entire performance testing monitoring data in Grafana . Grafana To facilitate a rapid experience of the entire performance testing process, the smart-doc community has curated and provided a template that can be launched with a single command using docker-compose . For those who wish to experience it through Kubernetes deployment, AI tools can be utilized to directly convert the docker-compose template into a Kubernetes deployment template. smart-doc docker-compose Kubernetes docker-compose Kubernetes The project for the experience also includes usage instructions. The example code for this article can be found here . here here The Assistance of Smart-Doc in JMeter Performance Testing The Assistance of Smart-Doc in JMeter Performance Testing The combination of smart-doc and JMeter for performance stress testing offers several advantages: smart-doc Automation: smart-doc can automatically extract API information from the source code and generate JMeter performance test scripts without the need for manual writing, greatly improving efficiency. Automation: smart-doc can automatically extract API information from the source code and generate JMeter performance test scripts without the need for manual writing, greatly improving efficiency. Automation: smart-doc Precision: The JMeter performance test scripts generated by smart-doc are completely consistent with the API definitions in the source code, avoiding errors that may occur when manually writing scripts. Precision: The JMeter performance test scripts generated by smart-doc are completely consistent with the API definitions in the source code, avoiding errors that may occur when manually writing scripts. Precision: smart-doc Flexibility: smart-doc supports a variety of configuration options, allowing the generated JMeter scripts to be customized according to testing requirements. Flexibility: smart-doc supports a variety of configuration options, allowing the generated JMeter scripts to be customized according to testing requirements. Flexibility: smart-doc smart-doc will also continue to improve and optimize support for JMeter. Please stay tuned for the ongoing development of the smart-doc open-source project . smart-doc ongoing development of the smart-doc open-source project ongoing development of the smart-doc open-source project Conclusion Conclusion By combining smart-doc and JMeter, we can not only automate the generation of API documentation but also swiftly create performance test scripts and conduct stress testing. This automation tool significantly enhances development and testing efficiency while helping teams more easily maintain and optimize the performance of software systems. smart-doc We hope this article has provided practical references for you to apply these tools more efficiently in your daily work. We also welcome everyone to continue to follow and support the smart-doc open-source community. In the future, we are exploring support for additional languages to assist more developers.

How to Simplify JMeter Script Creation With Smart-Doc

স্মার্ট-ডক দিয়ে কীভাবে জেমিটার স্ক্রিপ্ট তৈরি করা যায়

So vereinfachen Sie die Erstellung von JMeter-Skripten mit Smart-Doc

Cómo simplificar la creación de scripts JMeter con Smart-Doc

Comment simplifier la création de scripts JMeter avec Smart-Doc

स्मार्ट-डॉक के साथ JMeter स्क्रिप्ट निर्माण को सरल कैसे बनाएं

Smart-Doc で JMeter スクリプトの作成を簡素化する方法

Smart-Doc을 사용하여 JMeter 스크립트 생성을 단순화하는 방법

Como simplificar a criação de scripts JMeter com Smart-Doc

Как упростить создание сценариев JMeter с помощью Smart-Doc

Smart-Doc ile JMeter Komut Dosyası Oluşturma Nasıl Basitleştirilir

Cách đơn giản hóa việc tạo tập lệnh JMeter bằng Smart-Doc

如何使用 Smart-Doc 简化 JMeter 脚本创建

Testing smart contracts is really important. Why? Smart contracts are generally in production, , , and often involve . The short story? With smart contracts, you don’t want to screw up. You need to test a lot, test often, and test thoroughly. Smart contract testing involves all the usual suspects—unit testing, integration testing, automated testing— but also highly recommended is fuzzing—a way to bombard your code with a bunch of random inputs just to see what happens. immutable public targets of hackers significant financial implications Let’s take a look at exactly what fuzzing is as a testing method and how you can easily include it in your software testing workflow using tools such as ConsenSys . We’ll walk through a tutorial using an to see how it's done. Diligence Fuzzing example defi smart contact What is fuzzing testing and why would I use it? (or fuzz testing) involves sending millions of invalid, unexpected, and (semi) random data against a smart contract in an effort to cause unexpected behavior and detect vulnerabilities. It’s a fast, efficient, brute-force way to test edge cases and scenarios you might not think of. It complements your other testing flows and your audits. Fuzzing testing Fuzzing has been around for a while in traditional full-stack development, but a new class of tools is here that can apply fuzzing to smart contract testing in web3. Some of the fuzzing tools include the open source and . Echidna MythX In this article, however, I will take a deep dive into , which offers fuzzing as a service—a pretty cool and easy way to fuzz. Diligence Fuzzing To use Diligence Fuzzing, you annotate your smart contracts using . Basically, you use Scribble annotations in your code to tell the fuzzer what type of output to expect for that function. Scribble It looks something like this: /// #invariant {:msg "balances are in sync"} unchecked_sum(_balances) == _totalSupply; You call the fuzzer from a web UI where you submit the smart contract code. You hit run, and approximately 10 minutes later, you get a report with the issues found, location of issues, coverage %, and more. This is an easy and powerful way to check some edge cases. Testing a DeFi Smart Contract Let’s say we have a new DeFi protocol and corresponding token that we want to launch. DeFi is cutting-edge finance, fun to write, and it’s critical that we don’t have any bugs. DeFi smart contracts often involve millions (or more) in user funds. So we want to be sure our smart contracts are tested (and audited) as thoroughly as possible. IMPORTANT NOTE: This code has vulnerabilities in it ON PURPOSE! It’s so we can show how fuzzing can catch these mistakes. Please don’t really use this code for anything. Let’s get started. An example using Diligence Fuzzing (FaaS) Step 1: Set up a Diligence account. First, we need our Diligence account. Sign up at . You get 10 hours of fuzzing for free to try things out. Diligence Step 2: Create a new API key. Click your account name at the top right, click “create new API key”, and give it a name. This API key allows us to connect to the FaaS. Step 3: Set up your local environment. Clone the following repository: https://github.com/ConsenSys/scribble-exercise-1.git From the command line, navigate to the repository folder, which will now be your project root folder. If necessary for your machine, activate a Python venv. Then, run the following commands to install your project dependencies: $ npm i -g eth-scribble ganache truffle
$ pip3 install diligence-fuzzing Step 4: Enter your API key. Edit the file to use your Diligence account API key for the value of key. .fuzz.yml Your resulting file should look like this: .fuzz.yml

fuzz:
# Tell the CLI where to find the compiled contracts and compilation artifacts
build_directory: build/contracts

...
campaign_name_prefix: "ERC20 campaign"

# Point to your ganache node which holds the seed
rpc_url: "http://localhost:8545"

key: "DILIGENCE API KEY GOES HERE"

... Step 5: Write and annotate your contract. Now let’s check out our smart contract at . Here we have a vulnerable token (as it’s named!) for our new DeFi protocol. We clearly need to test it as much as possible. So let’s add a check using Scribble that the fuzzer will hopefully catch. contracts/vulnerableERC20.sol Above the contract definition, add: /// #invariant "balances are in sync" unchecked_sum(_balances) == _totalSupply; And above the transfer function, add: /// #if_succeeds msg.sender != _to ==> _balances[_to] == old(_balances[_to]) + _value;
/// #if_succeeds msg.sender != _to ==> _balances[msg.sender] == old(_balances[msg.sender]) - _value;
/// #if_succeeds msg.sender == _to ==> _balances[msg.sender] == old(_balances[_to]);
/// #if_succeeds old(_balances[msg.sender]) >= _value; So now let’s see if the fuzzing tester will catch something. Notice the annotations we’ve added to the contract to help the tester understand what we expect to happen. And notice in the config the tester is set to run for 10 minutes max, so it might not catch everything. Step 6: Fuzz around. Now we’re ready to test! From the project root folder, run to call the make file, which will compile, build, and send everything over to the FaaS. make fuzz Step 7: See the results. Go back to your dashboard, and you should see something similar to the below. Wait several seconds for the campaign to start. After it’s finished generating, you should see something similar to what is shown below: We even see code coverage! And after a few minutes, we see a failure! Clicking through to properties, we see any violations. And yes we have a bug! Click on the line location to see the details of our potential code vulnerabilities. We’ll stop there, but if you let the fuzzer keep running, it might find more! Conclusion Fuzzing can be a crucial step in your software development and testing process. It helps you identify potential vulnerabilities that otherwise may go unnoticed. By using it, you start to recognize and understand common pitfalls and challenges. Take advantage of tools such as , write better smart contracts, and become a better developer! Diligence Fuzzing

Fuzzing Around: Smart Contract Testing Through Random Inputs

Fuzzing Around: prueba de contrato inteligente a través de entradas aleatorias

Fuzzing Around : Test de contrat intelligent via des entrées aléatoires

फ़ज़िंग अराउंड: रैंडम इनपुट के माध्यम से स्मार्ट अनुबंध परीक्षण

ファジーアラウンド: ランダム入力によるスマート コントラクト テスト

Fuzzing Around: Teste de contrato inteligente por meio de entradas aleatórias

Fuzzing Around: Thử nghiệm hợp đồng thông minh thông qua đầu vào ngẫu nhiên

模糊测试：通过随机输入进行智能合约测试

GitHub Repo:- https://github.com/PradhumnaPancholi/Figbot Hey everyone! A little while ago, I was learning as it has fantastic tools for developing and auditing smart contracts. And although I loved the experience, I soon learned that it is in the clandestine development stage. This means that casual/individual users can not depend on maintainers for support and updates. Dapp Tools Then I stumbled upon . It has everything that Dapp Tools offers apart from built-in symbolic execution (which is not a problem for me as I use e by Trail of Bits ). And this is auditing related hence not a hindrance in smart contract development by any stretch of the imagination. Foundry Manticor After working with Foundry for a bit, I enjoyed the experience and wanted to share that with others. Hence, this article. This article will go through the benefits of Foundry, the installation process,  developing an NFT (because everyone is interested in that), testing the contract, and deploying it with . Figment Datahub Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust. Foundry is made up of three components: Ethereum testing framework (like Truffle, Hardhat, and Dapptools). Forge: Swiss army knife for interacting with EVM smart contracts, sending transactions, and getting chain data. Cast: local Ethereum node, akin to Ganache, Hardhat Network Anvil: Today’s focus is going to be on But I will be posting in-depth articles on Caste and Anvil in the upcoming weeks. Forge. Why Foundry: There are many smart contract development tools like Truffle, Hardhat, and Brownie. But one of my primary reasons for looking into Dapp Tools in  the first place was native Solidity tests. Writing smart contracts is not hard when switching between frameworks like Hardhat and Brownie. And they are incredible tools with plugins, but one needs to be well versed in JavaScript/TypeScript and Python to perform testing. Foundry allows us to write our tests natively in Solidity. This saves a lot of time onboarding new developers and makes the process smoother. In my experience of helping people navigate their way into smart contracts development, I have learned that the best and most efficient way for junior developers to engage with DAO/community-maintained projects is by writing tests and learning about the code-base itself. I remember once mentioned that they used the same approach while developing Alchemix Finance on . Scupy Trooples Bankless In addition to that, built-in fuzzing, cheat codes, Cast, and Anvil make it a solid suite for testing smart contracts. There will be more detailed articles on those components coming soon. [Easy to integrate static analyzer] Let’s dive in and build an NFT project now. Installation: If you are on Mac or Linux, all you need to do is run two commands: curl -L https://foundry.paradigm.xyz | bash foundryup Make sure to close the terminal before running . foundryup And Voila! You are all done. For Windows, you need to have Rust installed and then : cargo install --git https://github.com/foundry-rs/foundry --locked Project Setup: For this article, we will be creating a simple NFT project called Figbots. Start by creating a directory called “Figbots.” And  run once you are inside the directory. This command will create a foundry project for you with initialized. forge init git Let’s take a quick look at the folder structure. You have three primary folders, namely src, lib, and test. Very much self-explanatory here, you write your contracts in , tests in , and contains all the libraries you installed, e.g., OpenZeppelin. In addition to that, you get which contains all the configurations just like and if you have used those frameworks. Another sweet thing is .github, where you can write your Github Actions. I find it really helpful for tests when working in a team. src test lib foundry.toml hardhat.config.js brownie-config.yaml Let’s start building! We will create a simple NFT called Figbot with a limited supply, cost (for minting), and withdrawal. With this approach, we can cover edges for different tests. First of all, rename and to and respectively. Now, we can not write smart contracts without Openzeppelin, can we? Contract.sol test/Contract.t.sol Figbot.sol Figbot.t.sol Installing libraries with Foundry is slightly different than Hardhat and Brownie. We don’t have npm or pip packages. We install libraries directly from the Source (GitHub repo) in Foundry. forge install Openzeppelin/openzeppelin-contracts Now we can import the ERC721URIStorage.sol extension to create our NFT. To check that everything is alright, we can run the command , and it will compile our project. The compiler will yell at you if there is something wrong. Otherwise, you will get a successful compile. forge build Managing dependencies Just like any other package manager, Forge allows you to use , and to manage your dependencies. forge install <lib>, forge remove <lib> forge update <lib> Let’s Complete The NFT Contract: We will be using three contracts from the Openzeppelin. Counters, ERC721URIStorage, and Ownable. Time to upload our to IPFS using . We use the Ownable contract to set deploying address and have access to modifier to allow only the owner to withdraw funds. to help us with token id(s) and to keep the NFT contract simple. asset Pinata owner onlyOwner Counters ERC721URIStorage Setting state variable: to 100 MAX_SUPPLY to 0.69 ether COST to CID, we receive from Pinata TOKEN_URI Using Counter for token id: using Counters for Counters.Counter; Counters.Counter private tokenIds; ERC721 constructor: constructor() ERC721(“Figbot”, “FBT”) {} Mint function: Check if is greater than msg.value COST Check if is greater or equal to tokenIds.current() MAX_SUPPLY Perform and _safeMint _setTokenURI Withdraw function: function withdrawFunds() external onlyOwner {         uint256 balance = address(this).balance;         require(balance > 0, "No ether left to withdraw");         (bool success, ) = (msg.sender).call{value: balance}("");         require(success, "Withdrawal Failed");         emit Withdraw(msg.sender, balance);     } TotalSupply function: function totalSupply() public view returns (uint256) {                                         return _tokenIds.current();        } Testing The Contract: As we all know, testing our smart contracts is really important. In this section, we will be writing some tests to get a solid understanding of and get used to writing tests in native solidity. We will be three (I love them!) to manage account states to fit our test scenario. forge test Foundry cheat codes We will be testing for the following scenarios: Max Supply Successful mint Failed mint due to insufficient balance Withdraw (by owner) Cheatcodes As we can have complex logic in our smart contracts. And they are expected to behave differently depending on the state, the account used to invoke, time, etc. To deal with such scenarios, we can use cheatcodes to manage the state of the blockchain. We can use these cheatcodes using instance, which is a part of  Foundry’s library. vm Test We will be using three cheatcodes in our tests : : Sets for all subsequent calls until is called. startPrank msg.sender stopPrank : stopPrank Stops an active prank started by , resetting and to the values before was called. startPrank msg.sender tx.origin startPrank : Sets the balance of an address provided address to the given balance. deal Setup Foundry comes with a built-in testing library. We start by importing this test library, our contract (the one we want to test), defining the test, setting variables, and function. setUp pragma solidity ^0.8.13;

import"forge-std/Test.sol";
import "../src/Figbot.sol";

contract FigbotTest is Test {

  Figbot figbot;
  address owner = address(0x1223);
  address alice = address(0x1889);
  address bob = address(0x1778);
  
  function setUp() public {
      vm.startPrank(owner);
      figbot = new Figbot();
      vm.stopPrank(); 
  }
} For state variables, we create a variable of type . This is also the place where I like to define user accounts. In Foundry, you can describe an address by using the syntax . you can use any four alphanumeric characters for this. I have created the accounts named owner, Alice, and bob, respectively. figbot Figbot address(0x1243) Now our function. This is a requirement for writing tests in Foundry. This is where we do all the deployments and things of that nature. I used the cheatcode to switch the user to the “owner.” By default, Foundry uses a specific address to deploy test contracts. But that makes it harder to test functions with special privileges like . Hence, we switch to the “owner” account for this deployment. setUp startPrank withdrawFunds Test MaxSupply: Starting with a simple assertion test to learn Foundry convention. By convention, all the test functions must have the prefix . And we use to test if two values are equal. test assertEq We call our function and test if the result value is 100, as we described in our contract. And we use to run our tests. MaxSupply forge test And Voila!!! we have a passed test. Test Mint: Now that we have written a simple test, let’s write one with cheatcodes. The primary function of our contract. Switch user account to Alice. Set Alice’s balance to 1 ether Call the mint function Check if Alice is 1 balanceOf TestFail Mint: We have another testing function used for tests that we expect to fail. The prefix used for such a test is . We will test if the function reverts if the caller has insufficient funds. testFail mint Switch user account to Bob Set Bob’s balance to 0.5 ether (our NFT is 0.69 ether) Call the mint function (it will be reverted due to not having enough funds) Check if Bob is 1 balanceOf Because mint didn’t go through, the balance of Bob is not going to be 1. Hence, it will fail, which is exactly what we are used for. So when you run , it will pass. testFail forge test Test Withdraw: Here we will test a function that only the “owner” can successfully perform. For this test, we will : Switch user to Bob Give Bob’s account the balance of 1 ether Mint a Figbot from Bob’s account ( this will give the contract a balance of 0.69 ether ) Switch the user to the owner account Perform function ( if successful, it should make the owner’s balance 0.69 ether) withdrawFunds To verify, we assert if the owner’s balance is 0.69 ether Deployment: Now that we have tested our contract, it is time to deploy it. We need private keys to a wallet (with some Rinkeby test ETH) and an RPC URL. For our RPC URL, we will use . Figment DataHu Figment DataHub provides us with infrastructure to develop on Web 3. It supports multiple chains like Ethereum, Celo, Solana, Terra, etc. Setting up Figment DataHub: Create an account on . Figment DataHub Click on “Create New App.” Fill in the app name. Choose “Staging” for the environment. Select “Ethereum” from the provided options. You can get your RPC URL for Rinkeby from under the “Protocols” tab. Open your terminal to enter both of these things as environment variables. export FIG_RINKEBY_URL=<Your RPC endpoint>
export PVT_KEY=<Your wallets private key> Once we have the environment variables, we are all set to deploy forge create Figbot --rpc-url=$FIG_RINKEBY_URL --private-key=$PVT_KEY Verification: We are almost done here. So far, we have written, tested, and deployed a smart contract with Foundry and Figment DataHub. But we are not entirely done just yet. We are now going to verify our contract. We will need to set up our API key for that. Etherscan export ETHERSCAN_API=<Your Etherscan API Key> And now we can verify our smart contract. forge verify-contract --chain-id <Chain-Id> --num-of-optimizations 200  --compiler-version <Compiler Version> src/<Contract File>:<Contract>  $ETHERSCAN_API Congratulations! Now you can write, test, and deploy smart contracts using Foundry. I hope you enjoyed and learned from this article. I indeed enjoyed writing this. Feel free to let me know your thoughts about it.

How to Build an NFT Project with Foundry & Figment DataHub

Cómo construir un proyecto NFT con Foundry & Figment DataHub

Comment créer un projet NFT avec Foundry & Figment DataHub

फाउंड्री और फिगमेंट डेटाहब के साथ एनएफटी प्रोजेक्ट कैसे बनाएं?

Foundry & Figment DataHub を使用して NFT プロジェクトを構築する方法

Como construir um projeto NFT com Foundry & Figment DataHub

Cách xây dựng một dự án NFT với Foundry & Figment DataHub

如何使用 Foundry 和 Figment DataHub 构建 NFT 项目

Having faced the global crisis, countries are only starting to trailblaze the path toward normalcy. Although an epidemiological endpoint is still out of reach, organizations are preparing for the ‘next normal’ and embracing novel strategies to gain a competitive edge and accelerate productivity. For that, companies modified their businesses once and for all through and delivering more goods and services online. Statista mentions that by 2024, the on DT will double in comparison with 2020 and comprise $2.39 trillion!\ digital transformation (DT) global spending However, any changes are challenging, and digital ones are even more challenging. Organizations still struggle with implementing highly complicated solutions with AI, IoT, AR/VR, blockchain, or other modern technologies at the core. To ride the wave of innovation and companies may focus their efforts on quality assurance. But what QA tendencies to consider in 2022 to build an effective testing process and gain a competitive edge? attain boosted productivity and quality at speed, In the article, we will cover the top 5 software testing trends that will influence industry development in the years ahead and help businesses mitigate the COVID-19 aftermath. #1 – Continuous evolution of Agile and DevOps methodologies Organizations now are adjusting themselves to the post-pandemic era, and this process is characterized by the growing stake in introducing innovations and fit-for-purpose approaches. For instance, we’ve already observed in the shift to the tailored to help organizations deliver good-to-go code with built-in security from the get-go. Others infuse into their CI/CD pipelines, making QA a major function in the software development process. the uptick DevSecOps culture QAOps However, adopting novel practices inevitably means the rising need for a right-skilled talent pipeline. It is here when an issue of great concern arises. According to the World Quality Report 2021-22 (WQR), 44% of survey participants experience while another 31% stated that they face a gap in the shortage of expertise of agile testing teams, test environment, containerization, and test data skills. When it comes to easing the process of embedding in-demand methodologies and simultaneously optimizing their testing strategies, businesses can do the following: Shift QA activities left to care about software quality and prevent issues early in SDLC Rely on automated testing to build, test, and ship IT products faster Leverage AI to enable optimization of test cases Apply smart online dashboards to ensure end-to-end quality monitoring in real time. However, the most important recipe for success features the need to focus on as well as develop the ability business requirements and organizational culture, to embrace change. Why is sticking to Agile and DevOps so significant for companies today? When implemented right, these methodologies can save the day. Almost two-thirds of IT business representatives mentioned that they managed to boost productivity, software quality, delivery velocity, and the cost of quality. #2 – Quality engineering (QE) as a major function in digital transformation support COVID-19 pandemic has expedited the adoption of digital technologies worldwide. Global by Statista indicates that an overwhelming of respondents admitted a boost in DT processes velocity in their companies, while 68% assumed that DT speed was impressive. research 97% To handle increased demand in remote work and ensure business continuity, companies had to accelerate the digitization of supply chain interactions and significantly enlarge the number of digitally-driven solutions. This is no surprise when — improved productivity and efficiency, enhanced CX, polished quality, better organizational agility and flexibility, decreased expenses. There are even more benefits on the agenda. considering the outcomes However, the path to digital adoption is hard. Companies must embrace novel technologies and approaches like How to do it right, ensure high IT product quality, and mitigate cybersecurity and data privacy risks? 5G, edge computing, AI, IoT, intelligent automation, embedded software… Organizations may support software releases with QE. Focused on defect prevention and high velocity, it helps embed quality into the entire development process to reach seamless software operation and engaging user experience. While doing so, businesses have already marked QE engineers should possess in the future to cope with sophisticated tasks — cloud computing, cybersecurity, big data and analytics (WQR). must-have skills Nevertheless, the pace of change will likely slow down, and it’s great that despite facing novel challenges, companies are doing their utmost to ensure the impeccable operation of smart digital environments. #3 – AI and ML to attain a smart testing approach According to Statista, in North America alone, the profit from the AI software market will and comprise $50 billion by 2025. skyrocket From accounting and HR to digital marketing and travel industry, AI is making its way to disrupting business environments and boosting organizational capabilities. And software testing industry is no exception. The WQR highlights that in the future, we’ll witness the increasing implementation of this technology to strengthen the QA efforts, for instance, test automation. AI will expedite testing time and improve quality due to eliminating the human intervention factor. In this regard, Gartner states that by 2023, of infrastructure and operations teams in large-sized companies will give preference to AI-augmented automation for the sake of improving organizational efficiency. Used to develop and maintain automated scripts as well as enable scriptless automation and self-healing, 40% in software testing will also continue to constitute mature trends in the years to come. Eliminating excessive test cases within a suite, predicting issues in test models, test prioritization, and AI-driven analytics Although and associated with test strategy and test design, setup and generation of test data, bias and ethical validation in AI, and some others still exist, already today, more and more companies leverage this mighty innovation skill gaps needed from QE experts to improve the accuracy of testing results, enhance overall software quality, and decrease time to market. #4 – Intelligent automation to get faster business outcomes Test automation implementation will keep gaining momentum in the years ahead. Not surprising due to its multiple benefits — from better defects detection to reduced test cycle time. For example, within the WQR report, half of 1,750 of the interviewed IT leaders asserted that their test automation efforts are paying off, while almost 70% marked improved control and transparency of QA activities. It’s been rather challenging for organizations (e.g., with AI/ML or test automation architecture skills). However, businesses across diverse industries increase test automation adoption levels and gradually to engage the right-skilled specialists enlarge the scope of automation techniques in use. So, in the future, we may face a growth in the application of: to significantly streamline test activities and decrease human intervention Robotic process automation (RPA) to maximize reuse and minimize the need for hand-coding A scriptless (no-/low-code) approach to automation to provide tests with the ability to automatically update themselves to avoid failure if the function has changed Self-healing automation to extend testing coverage, boost velocity and performance by fulfilling more tests in a real browser environment Headless automation to briskly find and compile the right data for each test, enabling a less resource-intensive testing process. Automation of test data However, to bear fruit from intelligent test automation adoption and maintenance, companies should always remember a cardinal rule — aligning processes to unique business needs. #5 – IoT testing to support the operation of interconnected devices Statista again shares quite impressive data and valuable insights — the worldwide amount of will rise to 25.4 billion in 2030, while will grow from $389 billion in 2020 to $1 trillion! IoT devices IoT annual global revenue By representing the network of devices that communicate with one another and share data, IoT brings to the table multiple like efficient operation management, work safety improvements, reduced human labor, and many others. business benefits Moreover, the uptick in the adoption of a constantly connected has made this innovation one of the pivotal technologies for businesses in the years ahead. 5G technology, the boom in DT, IoT sensors usage in eHealth to fight the pandemic Noteworthy is the IoT role in the emergence of which have seen an increase in popularity. Just imagine: China alone is deploying approximately across the country. While Statista predicts that the for smart city technologies, products, and services will attain $129 billion this year. smart cities, 800 smart city programs worldwide revenue Keeping on the subject — Singapore, Dubai, and Oslo are great examples of the most impactful growing smart cities today, From connected vehicles and smart waste management solutions to smart air quality monitors and grids, their potential is almost limitless, with IoT at the core of their operation. ensuring their citizens a higher quality lifestyle. This is why comprehensive IoT testing should become a part of the software creation process. And a special emphasis should be placed on as the devices are connected to the Internet, which increases the probability of fraudulent attacks. IoT focused on verifying all possible combinations of devices and sensors will help spot vulnerabilities and system flaws. cybersecurity penetration testing Other high-priority testing types include functional, performance, compatibility, usability testing, test automation all aimed at and improving the quality of IoT-enabled networks. eliminating interoperability challenges The increased role of quality assurance COVID-19 is the problem we’ll all have to live with for the long haul. Luckily, businesses accelerated digital transformation pace, agile mindsets, and willingness to adopt innovations are among them. have shown the signs of successful adaptation to a briskly changing situation — However, digital adoption is challenging, requiring a whole set of professional skills and timely QA support. Open-minded companies have become more aware of software quality importance and may focus on the defining QA trends that will rule the industry in the upcoming year. Among them, it’s possible to highlight: The continuous popularity of Agile and DevOps QE as a means to support digital transformation The use of AI and ML to test smartly Automation to get faster business outcomes IoT testing to ensure swift operation of interconnected devices. By sticking to the technology-driven strategy with quality assurance at the helm, businesses can increase organizational performance and expedite the delivery time of quality software, so requisite in the post-pandemic world.

What the future holds: 5 core QA trends to rule 2022

The goal of this article is to demonstrate how to create an ERC20 token in as little time as possible. Let’s start with the basics: What is an ERC20 token? In recent years, the ERC20 token specification has become the defacto standard for Ethereum tokens. In other words, most Ethereum contracts out there today are ERC20-compliant. This article will detail how you can create your own Ethereum token, but before we get started, let’s take a closer look at the ERC20 standard. What makes ERC20 tokens so attractive and successful? There are several factors in play: ERC20 tokens are simple and easy to deploy, as you will see in this tutorial. The ERC20 standard solves a significant problem, as blockchain-based marketplaces and crypto-wallets need a single, standardized set of commands to communicate with the range of tokens they manage. This includes interaction rules between different tokens, as well as token purchase rules. It was the first popular specification to offer Ethereum token standardization. It was not by any means , but thanks to its popularity, it quickly became the industry standard. the first Just like other Ethereum tokens, ERC20 tokens are implemented as smart contracts and executed on the Ethereum Virtual Machine (EVM) in a decentralized manner. Solidity: the Smart Contract Programming Language Ethereum smart contracts are written in Solidity. While there are alternative languages, hardly anyone uses them for this purpose. Solidity is similar to JavaScript, so if you have some knowledge of JavaScript, or even Java and other C-like languages, you should have no trouble figuring out that a piece of code in Solidity does, even before you actually master Solidity enough to use it. This is where the fun starts, as you should be able to start creating a simple ERC20 contract in no time. This is a straightforward task, simple enough that this article will demonstrate how you can write and deploy an ERC20 token in under an hour. The token we will be creating in this demonstration will be a bare-bones ERC20 implementation, without too many bells and whistles. However, I have seen many similarly simple tokens in the real world, and they tend to do quite well. Overview of ERC20 Token Standard What is ERC20? Put simply, the ERC20 standard defines a set of functions to be implemented by all ERC20 tokens so as to allow integration with other contracts, wallets, or marketplaces. This set of functions is rather short and basic. function totalSupply() public view returns (uint256); function balanceOf(address tokenOwner) public view returns (uint); function allowance(address tokenOwner, address spender) public view returns (uint); function transfer(address to, uint tokens) public returns (bool); function approve(address spender, uint tokens) public returns (bool); function transferFrom(address from, address to, uint tokens) public returns (bool); ERC20 functions allow an external user, say a crypto-wallet app, to find out a user’s balance and transfer funds from one user to another with proper authorization. The smart contract defines two specifically defined events: event Approval(address indexed tokenOwner, address indexed spender, uint tokens); event Transfer(address indexed from, address indexed to, uint tokens); These events will be invoked or when a user is granted rights to withdraw tokens from an account, and after the tokens are actually transferred. emitted In addition to standard ERC20 functions, many ERC20 tokens also feature additional fields and some have become a de-facto part of the ERC20 standard, if not in writing then in practice. Here are a few examples of such fields. string public constant name; string public constant symbol; uint8 public constant decimals; Here are a few points regarding ERC20 and Solidity nomenclature: A public function can be accessed outside of the contract itself view basically means constant, i.e. the contract’s internal state will not be changed by the function An event is Solidity’s way of allowing clients e.g. your application frontend to be notified on specific occurrences within the contract Most Solidity language constructs should be clear if you already possess essential Java/JavaScript skills. Writing an ERC20 Token in Solidity Now that we’ve outlined the basics and explained what it takes to create an ERC20 token, it is time to start writing some logic. First, we need to define two mapping objects. This is the Solidity notion for an associative or key/value array: mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowed; The expression mapping(address => uint256) defines an associative array whose keys are of type address— a number used to denote account addresses, and whose values are of type uint256 — a 256-bit integer typically used to store token balances. The first mapping object, balances, will hold the token balance of each owner account. The second mapping object, allowed, will include all of the accounts approved to withdraw from a given account together with the withdrawal sum allowed for each. As you can see, the value field of the allowed mapping is by itself a mapping plotting account address to its approved withdrawal sum. These mappings together with all other contract fields will be stored in the blockchain and will be resulting in changes being propagated to all network user nodes. mined Blockchain storage is expensive and users of your contract will need to pay for, one way or another. Therefore you should always try to minimize storage size and writes into the blockchain. Now that we have the required data structures in place, we can start to actually write the ERC20 logic into the appropriate functions. Setting the Number of ICO Tokens How do we set the number of ICO tokens? Well, there are a number of ways of setting the maximal number of ICO tokens and this matter might be worth a lengthy discussion by itself. For the needs of our ECR20 tutorial, we shall use the simplest approach: Set the total amount of tokens at contract creation time and initially assign all of them to the “contract owner” i.e. the account that deployed the smart contract: uint256 totalSupply_; constructor(uint256 total) public { totalSupply_ = total; balances[msg.sender] = _totalSupply; } A constructor is a special function automatically called by Ethereum right after the contract is deployed. It is typically used to initialize the token’s state using parameters passed by the contract’s deploying account. msg is a global variable declared and populated by Ethereum itself. It contains important data for performing the contract. The field we are using here: msg.sender contains the Ethereum account executing the current contract function. Only the deploying account can enter a contract’s constructor. When the contract is started up, this function allocates available tokens to the ‘contract owner’ account. Get Total Token Supply function totalSupply() public view returns (uint256) { return totalSupply_; } This function will return the number of all tokens allocated by this contract regardless of owner. Get Token Balance of Owner function balanceOf(address tokenOwner) public view returns (uint) { return balances[tokenOwner]; } balanceOf will return the current token balance of an account, identified by its owner’s address. Transfer Tokens to Another Account function transfer(address receiver, uint numTokens) public returns (bool) { require(numTokens <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender] — numTokens; balances[receiver] = balances[receiver] + numTokens; emit Transfer(msg.sender, receiver, numTokens); return true; } As its name suggests, the transfer function is used to move numTokens amount of tokens from the owner’s balance to that of another user, or receiver. The transferring owner is msg.sender i.e. the one executing the function, which implies that only the owner of the tokens can transfer them to others. Solidity’s way of asserting a predicate is require. In this case that the transferring account has a sufficient balance to execute the transfer. If a require statement fails, the transaction is immediately rolled back with no changes written into the blockchain. Right before exiting, the function fires ERC20 event Transfer allowing registered listeners to react to its completion. Approve Delegate to Withdraw Tokens This function is most often used in a token marketplace scenario. function approve(address delegate, uint numTokens) public returns (bool) { allowed[msg.sender][delegate] = numTokens; emit Approval(msg.sender, delegate, numTokens); return true; } What approve does is to allow an owner i.e. msg.sender to approve a delegate account — possibly the marketplace itself — to withdraw tokens from his account and to transfer them to other accounts. As you can see, this function is used for scenarios where owners are offering tokens on a marketplace. It allows the marketplace to finalize the transaction without waiting for prior approval. At the end of its execution, this function fires an Approval event. Get Number of Tokens Approved for Withdrawal function allowance(address owner, address delegate) public view returns (uint) { return allowed[owner][delegate]; } This function returns the current approved number of tokens by an owner to a specific delegate, as set in the approve function. Transfer Tokens by Delegate The transferFrom function is the peer of the approve function, which we discussed previously. It allows a delegate approved for withdrawal to transfer owner funds to a third-party account. function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) { require(numTokens <= balances[owner]); require(numTokens <= allowed[owner][msg.sender]); balances[owner] = balances[owner] — numTokens; allowed[owner][msg.sender] = allowed[from][msg.sender] — numTokens; balances[buyer] = balances[buyer] + numTokens; Transfer(owner, buyer, numTokens); return true; } The two require statements at function start are to verify that the transaction is legitimate, i.e. that the owner has enough tokens to transfer and that the delegate has approval for (at least) numTokens to withdraw. In addition to transferring the numTokens amount from owner to buyer, this function also subtracts numTokens from the delegate’s allowance. This basically allows a delegate with a given allowance to break it into several separate withdrawals, which is typical marketplace behavior. We could stop here and have a valid ERC20 implementation. However, we want to go a step further, as we want an industrial strength token. This requires us to make our code a bit more secure, though we will still be able to keep the token relatively simple, if not basic. SafeMath Solidity Library is a Solidity library aimed at dealing with one way hackers have been known to break contracts: integer overflow attack. In such an attack, the hacker forces the contract to use incorrect numeric values by passing parameters that will take the relevant integers their maximal values. SafeMath past protects against this by testing for overflow before performing the arithmetic action, thus removing the danger of overflow attack. The library is so small that the impact on contract size is minimal, incurring no performance and little storage cost penalties. SafeMath Let’s add to our code: SafeMath library SafeMath { // Only relevant functions function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a — b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } uses assert statements to verify the correctness of the passed parameters. Should assert fail, the function execution will be immediately stopped and all blockchain changes shall be rolled back. SafeMath Next, let us add the following statement introducing the library to the Solidity compiler: using SafeMath for uint256; Then, we replace the naive arithmetics we used at the beginning with SafeMath functions: balances[msg.sender] = balances[msg.sender].sub(numTokens); balances[receiver] = balances[receiver].add(numTokens); balances[buyer] = balances[buyer].add(numTokens); balances[owner] = balances[owner].sub(numTokens); Packing it all Together In Solidity, a smart contract’s functions and events are wrapped into an entity called a which you can silently translate to a “blockchain class.” Below is the ERC20-compatible contract we created, including a Gist of our code. The name and symbol fields can be changed at will. Most tokens keep the decimal value at 18, so we will do the same. contract Ethereum Contract Deployment The time has come to . Following deployment, our contract will be transferred to all nodes participating in the network. Any and all changes made to the contract will be propagated to all participating nodes. deploy our contract to the blockchain Ethereum developers usually employ deployment tools such as . Even Truffle is overkill for the limited needs of this article, and a simple online tool called will suffice. Truffle Remix To use it, you will need to install the on your browser and a Rinkeby (Ethereum test network) account with at least some Rinkeby Ether in it. These are relatively simple steps, so we won’t go into detail. MetaMask plugin In case you don’t have either, head over to and for download links and to get clear installation and usage directions. MetaMask Rinkeby Now that we have all the building blocks in place, we will head over to and paste the code above, including the pragma line and the SafeMath library, into the online editor. Remix Then, we will hop over to the second tab to the right called “ ” and click “ .” A MetaMask popup will appear asking us to confirm the transaction. Of course, we’ll approve it. Run Deploy Green box: Make sure you’re on Rinkeby Blue box: Set your total token supply Red box: Deploy! : Gist https://gist.github.com/giladHaimov/8e81dbde10c9aeff69a1d683ed6870be#file-basicerc20-sol You have just deployed your first ERC20 token, like a true . As promised, the token is simple and lightweight, yet fully functional, ERC20 standard compliant, and secured with MathSafe. It is ready to be purchased, paid with, and transferred throughout the Blockchain. Congrats! Ethereum professional Is that all there is to smart contracts? No, not even close, as our brief demonstration barely scratches the surface and deals solely with one aspect of smart contract development. Smart contracts can be much more complex depending on your business logic, your modeling of the user interaction, whether or not you allow token minting and burning, lifecycle changes you introduce into the contract, the need for admin-level capabilities which usually comes with an admin-authorized set of functions, and so on. You get the picture. Still, if you can replicate what we did here, that is a solid foundation to expand your knowledge and move on to more complex contracts when necessary. A smart contract is a piece of code executed on the Ethereum Virtual Machine. An Ethereum smart contract is immutable and can send or receive ether and data. Put simply, ERC20 tokens are contracts that implement the ERC20 standard. Operations handled by these contracts include getting the total supply and balance of tokens, and the methods used to transfer them. Ethereum development is currently conducted in Solidity, a contract-oriented programming language inspired by JavaScript, Python, and C++. ERC stands for Ethereum Request for Comment. The number 20 is assigned to this request, hence the suffix. Originally published at www.toptal.com .

How to Create an ERC20 Token the Simple Way

Testops and the emergence of Quality Intelligence

Running all regression tests all the time can be impractical and inefficient and represent a paradigm shift in software development, promoting collaboration, automation, and a continuous feedback loop. These practices are instrumental in meeting the demands of a dynamic and competitive market, allowing organizations to deliver high-quality software quickly and efficiently. DevOps continuous deployment In this context, has undergone a transformation to align with the accelerated pace of development methodologies, emphasizing the roles of test automation and continuous testing practices. However, with the increasing complexity of applications, the number of automated tests tends to grow exponentially. This growth results in prolonged execution times even for automated tests, sometimes spanning hours or days, contradicting modern development practices that prioritize quick feedback loops. software testing This presents a unique challenge for testing teams: the necessity to due to resource constraints and time limitations. The sheer volume of tests can lead to a tipping point where it becomes impractical to execute every test in every regression cycle. strategically select and prioritize tests The team is then confronted with the critical task of , employing some type of prioritization criteria, and continually maintaining and updating the test suite to ensure relevance and effectiveness within the context of the adopted criteria. identifying and focusing on high-priority test cases Strategies for selecting and prioritizing test cases Considering the trade-offs between and more focused , the crucial challenge is to methodically select and prioritize test cases within the test suite, aiming to strike a delicate balance between comprehensive coverage and the effectiveness of the testing process while being mindful of resource limitations. comprehensive automated regression testing partial regression In the list below, you'll discover various methods to prioritize test cases, all intended to strike a balance between comprehensive coverage and reducing execution time. Keep in mind that this list is not exhaustive: In this article, our goal is to examine . By merging these approaches, testing teams can devise a prioritized test plan, optimizing the efficacy of their testing efforts and enhancing the overall quality of the application under test. how the integration of business impact and frequency of use methods can lead to a more comprehensive approach to test prioritization Combining the business impact and frequency of use to prioritize test cases Often, teams find themselves struggling with the challenge of quantifying the business impact and frequency of use, resorting to an intuitive and subjective approach. To elevate confidence levels, it becomes imperative for teams to transition towards a more formalized methodology. This involves the that integrates both the business impact and frequency of use for the application's functionality. This formalized approach empowers teams to prioritize test cases more effectively based on these crucial factors, minimizing reliance on guesswork. development of a systematic scoring system Here's a step-by-step guide to prioritize tests using these factors: Review the business requirements and features of your application or system. Identify those with the most substantial impact on business operations, customer satisfaction, or revenue. Identify critical business requirements and features: Analyze usage data or gather stakeholder feedback to pinpoint the most frequently used features or functionalities in production. Assess frequency of use: Develop a matrix that blends both business impact and frequency of use factors. Assign weights or scores based on their relative importance to your company. Create a prioritization matrix: Map your test cases to the corresponding requirements or features. Calculate a priority score for each test case by combining the scores or weights assigned to the business impact and frequency of use factors. Prioritize test cases: By following this approach, you can focus your testing efforts on the most business-critical and frequently used aspects of your application or system while ensuring a well-rounded test coverage. Gravity: Applying AI for test case prioritization introduces an test case weighting & scoring engine that helps optimize existing test suites by prioritizing test cases based on the business impact and frequency of use in the tested pages and flows covered by these test cases. This enables a , focusing test coverage on high-impact areas that directly affect the end-user experience. Gravity AI-powered data-driven test case prioritization It seamlessly correlates multiple dimensions, including test coverage, business impact, and frequency of use. This enables the generation of easily understandable reports and insights, empowering testing teams to prioritize tests based on concrete data rather than relying on guesswork. Gravity's ability to by processing the ingested data through machine learning algorithms. This involves translating raw data into meaningful insights using techniques such as pattern recognition, trend and correlation analysis, anomaly and outlier detection, and more. monitor usage within the production and testing environments allows it to generate comprehensive quality analytics It highlights information that allows testing teams to , pinpoint features that may be either over-tested or under-tested, and recognize redundant testing efforts in less critical areas. identify gaps in coverage If you want to learn more about Gravity, you can book a demo here: Book a demo Conclusion Embracing a focused and selective is crucial for optimizing testing resources, accelerating time-to-market, and elevating overall software quality. By directing efforts toward high-risk areas of the application, testing teams can ensure the early discovery of critical issues. test case prioritization approach Additionally, the adoption of a formalized scoring system for provides a considerable benefit for testing teams. This systematic method represents a significant improvement over relying solely on subjective opinions and the experiences of others. By employing a more , testing teams can significantly enhance their testing practices, ensuring a more rigorous and effective approach to identifying and addressing critical issues. prioritizing relevant test cases objective and data-driven methodology Author: Cristiano Caetano Head of Growth at Smartesting Software testing authority with two decades of expertise in the field. Brazilian native who has called London home for the past six years. I am the proud founder of Zephyr Scale, the leading Test Management application in the Atlassian ecosystem. Over the last ten years, my role has been pivotal in guiding testing companies to build and launch innovative testing tools into the market. Currently, I hold the position of Head of Growth at Smartesting, a testing company committed to the development of AI-powered testing tools.

Turbocharge Regression Testing: Prioritizing Test Cases Like a Pro with AI

টার্বোচার্জ রিগ্রেশন টেস্টিং: এআই সহ প্রো-এর মতো পরীক্ষার ক্ষেত্রে অগ্রাধিকার দেওয়া

Turbocharge-Regressionstests: Testfälle priorisieren wie ein Profi mit KI

Pruebas de regresión de turbocompresor: priorizar casos de prueba como un profesional con IA

Tests de régression Turbocharge : prioriser les cas de test comme un pro avec l'IA

टर्बोचार्ज रिग्रेशन परीक्षण: एआई के साथ एक पेशेवर की तरह परीक्षण मामलों को प्राथमिकता देना

ターボチャージ回帰テスト: AI を使用してプロのようにテスト ケースに優先順位を付ける

터보차지 회귀 테스트: AI를 사용해 전문가처럼 테스트 사례 우선순위 지정

Teste de regressão turbocharge: priorizando casos de teste como um profissional com IA

Регрессионное тестирование с турбонаддувом: расстановка приоритетов тестовых случаев с помощью искусственного интеллекта как профессионал

Turboşarj Regresyon Testi: Yapay Zeka ile Bir Profesyonel Gibi Test Durumlarına Öncelik Verme

Thử nghiệm hồi quy tăng áp: Ưu tiên các trường hợp thử nghiệm như một chuyên gia với AI

涡轮增压回归测试：像人工智能专家一样确定测试用例的优先级

Bridging the Test Coverage Gap With Proactive Monitoring in Production and Testing Environments

উত্পাদন এবং পরীক্ষার পরিবেশে সক্রিয় পর্যবেক্ষণের মাধ্যমে পরীক্ষার কভারেজ গ্যাপ পূরণ করা

Überbrückung der Testabdeckungslücke durch proaktive Überwachung in Produktions- und Testumgebungen

Cerrar la brecha en la cobertura de pruebas con monitoreo proactivo en entornos de producción y pruebas

Combler le déficit de couverture des tests grâce à une surveillance proactive dans les environnements de production et de test

उत्पादन और परीक्षण परिवेश में सक्रिय निगरानी के साथ परीक्षण कवरेज अंतर को पाटना

実稼働環境とテスト環境でのプロアクティブなモニタリングによりテスト カバレッジのギャップを埋める

프로덕션 및 테스트 환경에서 사전 모니터링을 통해 테스트 범위 격차 해소

Preenchendo a lacuna de cobertura de teste com monitoramento proativo em ambientes de produção e teste

Устранение разрыва в тестовом покрытии с помощью упреждающего мониторинга в производственных и тестовых средах

Üretim ve Test Ortamlarında Proaktif İzleme ile Test Kapsamı Açığının Kapatılması

Thu hẹp khoảng cách về phạm vi kiểm thử bằng tính năng giám sát chủ động trong môi trường sản xuất và thử nghiệm

通过生产和测试环境中的主动监控来缩小测试覆盖率差距

Stories, News & Mentions about SMARTTESTING

Smarttesting’s Stories on HackerNoon