This guide explains how to create a globally unique, auto‑incrementing variable in JMeter by using a synchronized Groovy script that leverages the built‑in props object, demonstrates setting an initial value, and compares locked versus unlocked execution results.
The author shares a series of JMeter demos that leverage Groovy for context access, variable handling, command execution, request manipulation, regex extraction, cookie and header processing, and throughput error analysis, while recommending thorough documentation review and community interaction to deepen JMeter expertise.
This guide provides a step‑by‑step tutorial on using Apache JMeter for performance testing, covering JDK and JMeter installation, creating a complete test script for a Baidu search API, configuring thread groups, HTTP requests, listeners, assertions, executing the test, and analyzing the aggregate report results.
This article explains how to build a robust Redis-based distributed lock in a Spring MVC Java project, addressing lock expiration issues by adding a postponement thread, and demonstrates the solution with complete source code, Maven dependencies, testing using JMeter, and performance results.
This article demonstrates how to use Groovy scripts within JMeter’s JSR223 pre‑processor to generate RSA‑based signatures for request parameters, providing a complete utility class, configuration steps, sample code, and console output to verify that the signature is correctly added to the request.
This article provides a curated collection of Groovy tutorials covering topics such as Java‑Groovy integration, stream‑based prime calculation, shell scripting, database operations with Gradle, Groovy Shell usage, operator overloading, JMeter scripting, regular expressions, tuples, lists, and advanced Gradle‑Groovy techniques.
This article demonstrates how to use Groovy scripts within JMeter's JSR223 pre‑processor to generate RSA signatures for request parameters, covering key handling, encryption, decryption, signing, verification, map conversion, and how to attach the signature to the HTTP sampler for automated performance testing.
This article explains how to use JMeter to limit output bandwidth by configuring httpclient.socket.http.cps and httpclient.socket.https.cps, enabling realistic simulation of various mobile network speeds such as GPRS, 3G, 4G, Wi‑Fi, and Ethernet, and shows how to apply these settings via user.properties or command‑line parameters.
The article shares a series of JMeter demos that leverage Groovy for accessing the test context, retrieving SampleResult and previous sampler data, discusses the limited usefulness of thread scheduling via Groovy, highlights a discovered throughput discrepancy, and provides practical advice and links to related technical resources.
This article compiles a series of JMeter tutorials and presents a detailed, code‑driven walkthrough for using Groovy to add, read, and modify HTTP headers via the HeaderManager and JSR223 pre‑processor, complete with screenshots and sample console output.
This article provides a comprehensive tutorial on handling HTTP cookies in JMeter using Groovy scripts, covering the creation and configuration of CookieManager, adding and modifying cookies, executing JSR223 pre‑processors, and interpreting console output, supplemented with code examples and screenshots.
This article demonstrates how to apply Groovy regular expressions within JMeter to extract fields from API responses, showing step‑by‑step configuration of a thread group, JSR223 post‑processor script, and variable handling for performance testing.
The article reveals that JMeter often reports inflated throughput because it includes client‑side processing time—such as regex extraction and post‑processors—in its calculations, leading to misleading performance metrics unless corrected with micro‑benchmark adjustments.
This guide demonstrates how to add a JSR223 PostProcessor with Groovy in Apache JMeter to capture slow requests, write request parameters and responses to a log file, and control pagination for automated performance testing, providing complete script examples and console output.
This tutorial explains how to employ Groovy scripts within JMeter to dynamically modify request parameters, covering setup of a thread group, adding a JSR223 PreProcessor, example code, console output verification, and result tree inspection for GET and POST requests.
This article demonstrates how to execute operating‑system commands from a Groovy script inside JMeter’s JSR223 PreProcessor, showing the required test plan setup, the Groovy code, and the resulting console output for performance testing purposes.
This tutorial shows how to use Groovy scripts inside JMeter to set and retrieve both thread‑local (private) and thread‑shared (global) variables, providing step‑by‑step configuration, code snippets, and sample console output for each case.
This guide details a step‑by‑step process for creating, debugging, and scaling JMeter scripts, performing sandbox tests on BlazeMeter, configuring engine user limits, building clusters, and using master‑slave mode to achieve a 50 k concurrent‑user load test.
The article compares five widely used API testing tools—Rest‑Assured, Postman, SoapUI, JMeter, and Fiddler—explaining their strengths, ideal team compositions, and integration capabilities to help teams select the most suitable solution for their DevOps and automation needs.
This guide walks operations engineers through understanding server bottlenecks, setting up JMeter's distributed load testing environment on Windows and Linux, configuring assertions and variables, analyzing performance results, and monitoring both concurrency and stability tests to ensure reliable scalability.
This guide explains how to build an automated interface‑testing pipeline using Jenkins, Ant, JMeter and Groovy, generate test reports, filter out false‑positive failures caused by network or environment issues, let users confirm them in Jenkins, and recalculate success, failure and false‑positive rates.
This article guides readers through preparing gRPC RPC scripts, creating Java sampler code for JMeter, packaging the scripts, and executing load tests to evaluate RPC performance, providing step‑by‑step instructions and code examples for Java‑based testing.
This article explains load testing fundamentals, including its purpose, key performance indicators such as TPS and response time, detailed testing steps, scenario design considerations, a practical example, common issue analysis, and an overview of tools like JMeter and Locust.
This guide explains how to capture HTTPS traffic from an iOS app with Fiddler, configure the device proxy and certificates, and then recreate the login and query requests in JMeter to build automated API test cases, including token extraction and response validation.
This guide walks through configuring JMeter to connect to MySQL and Oracle databases via JDBC, covering driver installation, JMeter component setup, request creation, result verification, and troubleshooting common connection errors for performance testing.
This guide explains how to configure a Jenkins slave Docker image by installing JDK, Maven, and other build tools, adding the agent.jar, setting environment variables, and providing a startup Bash script to launch the Jenkins agent within the container.
This guide explains how to install Apache Ant, configure a build.xml file to run JMeter tests and generate HTML reports, and execute the Ant build to produce performance test results, including troubleshooting common permission errors.
This article provides a step‑by‑step tutorial on installing JMeter, configuring environment variables, launching the tool, creating a test plan with thread groups and HTTP requests, and running performance tests on API endpoints, illustrated with screenshots and command‑line examples.
This article explains a practical approach to performance‑testing Dubbo add and delete methods of a message queue by pre‑generating payloads, using a thread‑safe LinkedBlockingQueue, and driving the calls with JMeter‑compatible Java code.
This guide walks you through the complete process of planning, scripting, locally testing, and scaling a load test to over 50,000 concurrent users using JMeter and BlazeMeter, covering script creation, sandbox configuration, engine sizing, cluster setup, and master‑slave orchestration.
This article explains how to dynamically encrypt API request parameters with an MD5 signature by creating a Java utility, integrating it into JMeter via a BeanShell PreProcessor, and alternatively configuring the same logic in Postman's Pre-request Script for testing and load‑testing purposes.
This article explains how to identify and resolve two common factors—port number limits and file descriptor limits—that restrict server connection counts during MQTT performance testing with JMeter, providing step‑by‑step guidance and command‑line adjustments such as updating the ulimit value.
This tutorial explains how to dynamically encrypt API request parameters using MD5 signatures in JMeter with a BeanShell PreProcessor and also demonstrates the equivalent setup in Postman's pre‑request script, covering jar integration, variable handling, and practical testing tips.
This article explains how to conduct performance testing for long‑connection services such as MQTT using JMeter, highlights common factors that restrict connection counts like system port limits and file descriptor caps, and provides step‑by‑step instructions to adjust sysctl and ulimit settings to obtain accurate results.
This report details the background, objectives, environment, test plan, distributed JMeter setup, server monitoring, results, and analysis of a load‑testing effort aimed at identifying performance bottlenecks and validating reliability of a front‑end Node.js quality‑inspection service under increasing concurrent traffic.
This article explains how to integrate Microsoft Azure DevOps Server (formerly TFS) with the open‑source load‑testing tool JMeter, describing the background of DevOps testing challenges, JMeter features, a demo PartsUnlimited project, pipeline design, environment setup, script execution, and performance‑testing options.
This article introduces Badboy as a free web‑script recorder, explains how to add assertions and parameterize variables, shows how to export the recorded script to JMeter, and outlines the subsequent steps to run a performance test with JMeter.
This article explains comprehensive methods for testing lottery modules—including probability verification, high‑concurrency simulation with JMeter, and real‑time data monitoring using Grafana—to ensure stable, accurate prize distribution during large‑scale promotional events.
This article outlines a comprehensive, step‑by‑step approach to performance testing and root‑cause analysis for backend services, covering environment validation, tool selection, Linux system limits, dependency checks, empty‑endpoint verification, throughput calculation, log monitoring, and essential Linux commands such as netstat, vmstat, mpstat, iostat, top and free.
This guide explains how to set up JMeter’s PerfMon plugins for both GUI and non-GUI server performance monitoring, including required plugin downloads, agent installation, JAR placement, test plan configuration, command-line execution, and result analysis.
This guide explains how to use JMeter's command‑line mode and the JMeter Plugins CMD tool to convert JTL files into HTML reports and various chart types, detailing required parameters, plugin installation, and example commands for comprehensive performance‑testing reporting.
This article explains how JMeter implements its various distributed testing modes, examines the SampleSender interface and its overloads for standard, batch, and asynchronous modes, and presents optimization techniques that reduce network overhead and improve overall load‑testing performance.
This article explains JMeter's distributed testing capabilities, compares standard, batch, and asynchronous modes, and shows performance results using a visual platform, highlighting how controller bottlenecks can affect load testing at scale.
This guide walks through downloading JMeter source, importing it into Eclipse, resolving dependencies, building the project, customizing the core to print concurrent users every five seconds, packaging the modified JAR, and running a gradient load test on a Linux server.
This article introduces JMeter as an open‑source Java‑based performance testing tool, explains its directory and code structure, describes how to compile and run it with Ant, and provides a step‑by‑step guide to extending JMeter with a custom JSON assertion and GUI component.
This report details the performance testing of the 360 Endpoint Security Management System, covering product overview, architecture, tool selection (favoring LoadRunner), test scenarios, script implementation, execution results, resource utilization, and analysis, concluding with insights on testing methodology and optimization.
This article compares JMeter, LoadRunner, Locust, asyncio (Python) and Go-based load testing tools by measuring CPU, memory, Nginx response and TPS under varying concurrency levels, concluding that Go delivers the highest throughput while Python coroutines offer significant improvements over older Python versions.
This guide shows how to connect JMeter performance testing with Jenkins continuous integration by setting up JMeter test plans, running them via GUI or command line, configuring Jenkins jobs with the Performance plugin, and automating result collection for each build.
This article explains which external and internal performance metrics matter for backend services, how to interpret them, common bottlenecks, and provides a step‑by‑step example using JMeter to measure throughput, latency, CPU, memory, load, network and disk I/O.
This article introduces load‑generating tools, compares their performance, and provides a step‑by‑step Tsung installation and XML configuration to help engineers build a web cluster capable of handling millions of requests per second.
This article explains how to achieve ultra‑high HTTP request rates by using load‑generating tools such as Apache Bench, httperf, JMeter and Tsung, discusses Linux socket limits, provides step‑by‑step installation and configuration examples for Tsung on CentOS, and shows how to run tests and interpret the results for building a high‑performance web cluster.
This tutorial walks you through installing JMeter, creating a Thread Group, configuring HTTP requests, adding headers, listeners, assertions, variables, and correlation to fetch weather data from a public API, providing screenshots and a complete script so you can replicate the load test yourself.
