Performance Testing using LoadRunner 12.50

Discover why a performance tester must understand application architecture to identify bottlenecks, using monitoring and in-depth analysis of the architecture.

Understand how file, print, database, and application servers process only their respective requests, and how database and app servers use queries and deploy code to power apps like Gmail.

Explore n-tier architecture with web, app, and database servers, highlighting the presentation and business logic layers, stateless requests, and end-to-end transaction flows for performance testing.

Learn to identify bottlenecks in a web app architecture using LoadRunner, timing across web server, app server, and database, and profiling tools like Dynatrace.

Discover how protocols govern client-server communication in performance testing, explaining HTTP/HTTPS, FTP, SMTP, and TCP, and how web servers implement these rules.

Identify LoadRunner 12.50 hardware and software requirements, including Windows 10 compatibility, 8 gb RAM, dual-core 2.2 GHz, 50 gb disk, and verify installation of analysis, controller, and virtual user generator.

Master performance testing concepts in LoadRunner: speed, stability, and scalability, testing current and future loads, and validating a production-like environment with virtual users to meet non-functional requirements.

Define key performance testing terms, explain think time versus response time, distinguish transaction response time, and introduce throughput as transactions per second for LoadRunner projects.

Differentiate performance testing from performance engineering by identifying bottlenecks and eliminating them. As a performance engineer, fine-tune web servers, app servers, load balancers, databases, and networks to minimize response times.

Explore the performance testing lifecycle, from nonfunctional requirements gathering and sign-off to planning, design, execution, bottleneck analysis, and iterative fixes for fast application performance.

Gather nonfunctional requirements for performance testing by collecting infrastructure details for production and testing environments, then identify performance critical transactions by frequency, business impact, and resource intensity.

Identify performance critical transactions and gather transaction volumes, peak hours, scalability, and workload data to define non-functional requirements and response-time metrics.

Learn to use pacing in workload modeling to meet twelve login transactions per hour with two concurrent users by deploying multiple virtual users and applying a pacing formula.

Explore the LoadRunner 12.50 components: analysis, controller, and virtual user generator, plus the load generator, and learn how they fit the performance testing lifecycle from design to analysis.

Discover how VUGen records user actions, generates scripts via recording, and uses virtual users to simulate login and mail operations for performance testing, including playback and workload modeling.

The controller runs multiple scripts simultaneously with the number of virtual users and load you set, simulating real-world activity to produce realistic response times.

Analyze test results with the analyzer to review response times and end results, then generate a detailed test report using the same component.

Explore how load generators, the controller, and analysis are installed on separate machines in a real-time performance testing setup, with a single controller shared by multiple testers.

Explore calculating LG capacity and virtual users in LoadRunner 12.50 by evaluating memory footprint, RAM, license limits, and group configurations managed by the controller.

Explore the virtual user generator, its panes and layouts in LoadRunner 12.50, learn the default and plane layouts, docking, and how to record and playback scripts.

Learn to create a LoadRunner script by understanding the application and test, recording, enhancing, and playback, using the web tools sample app to practice; most work happens during recording.

Discover how the protocol advisor in LoadRunner helps identify the client–server protocol before recording, so the region can capture network-level traffic accurately.

Create and manage web http html scripts with protocol advisor in VuGen, select the correct protocol, and organize scripts into solutions with default actions like user_init and vuser_init.

Learn to create and name multiple actions in VUGen. Organize login, booking flight tickets, and cancel flight tickets into actions or user init and user end while recording.

See how VUGen records events during log in and log off, uses comments to tag code blocks, and organizes scripts into launch and log off sections for performance testing.

Set the protocol in VuGen before recording to ensure network-level capture. Use the technical design document and protocol advisor to identify and choose the best protocol.

Learn to verify VUGen scripts by stepping through each code block, watching the runtime viewer, and apply correlation to dynamic values to ensure accurate, repeatable performance tests.

VuGen run-time settings determine the execution flow and iterations, overriding the script order to manage login, booking tickets, and logout with think time controls.

Learn to playback VuGen scripts in Chrome using browser emulation and runtime settings, manage user agent strings, and simulate OS versions, while configuring bandwidth and speed emulation.

Learn how to insert and manage comments in LoadRunner VuGen during playback, and define transactions to measure end-to-end response times for login and logout.

Use VuGen to insert start and end transactions to capture login and launch page timings, manage think time during debugging, and follow case-sensitive naming standards.

Build load testing workflows with a main action that calls login, booking tickets, and logout actions, controlling order via runtime settings and printing to the output log.

Learn how html based and url based scripts trigger multiple web resources, and how parallel and sequential requests affect page load, using developer tools to diagnose performance.

Explore html-based versus url-based scripts in LoadRunner 12.50, where html packs launch page resources into one request, and url-based creates multiple web requests.

Explore HTML-based versus URL-based scripting to measure page performance with start and end transactions. Define sub transactions for web resources, use cache cleanup, and compare browser tools for accurate timing.

Understand how load testing uses checkpoints to validate server responses, including text and image checkpoints, and learn how to select unique text to avoid false passes.

Learn to add text checkpoints in LoadRunner 12.50 using the bridge file by selecting text in the response body, and understand troubleshooting with recording, replay, and snapshot views.

Learn to implement and validate text checkpoints in LoadRunner 12.50, including case-insensitive matching, selecting text via snapshot view, and using the web bridge to verify responses within transactions.

Discover how image checkpoints in LoadRunner 12.50 run after requests, differ from text checkpoints, and how to configure web image check using alt or source attributes with verification checks enabled.

Learn C functions in LoadRunner, understand variables as changing containers or placeholders, and connect basic data types to how values change and are stored.

Master C data types in performance testing with integers, floats, and strings, and learn declaration and initialization of variables, including default values in LoadRunner 12.50 contexts.

Declare variables at the start of the script with meaningful names, ensure proper initialization and type declarations, then compile to catch syntax errors and observe variable values.

Learn how to declare and initialize strings in C within LoadRunner, using characters, pointers, and arrays, and handle placeholders like %c and memory violations.

Compare two integers, floats, and strings in C using conditional statements, and learn why string comparisons require a dedicated C function for equality checks.

Discover how a lab parameter can hold integers, strings, or floats, with no prior declaration, and learn to copy values between data types using lr_save_int and lr_save_string.

Convert values from a large parameter into a string in LoadRunner 12.50 using the lr_string function, including creating alert parameters, moving contents, and storing results in a string variable.

Explains converting between string and integer in LoadRunner C functions, including string to integer via ASCII concepts and integer to string with sprinter, and indirect LR parameter handling.

Explore error handling in LoadRunner 12.50 by using text checkpoints and start and end transactions to verify login flows and detect pass/fail from welcome text.

Explore conversions in performance testing with LoadRunner, converting parameters to strings then integers to enable proper comparisons. The lecture covers buffers, watches, error handling, and step-by-step versus continuous execution.

Parameterization replaces hardcoded login credentials with a parameter, enabling each iteration to simulate different users. Follow three steps: create a parameter, assign values, and replace hardcoded values with the parameter.

Learn how to parameterize real time scripts in loadrunner, including usernames, passwords, and other form fields for web and banking applications, by creating parameters, supplying values, and replacing hardcoded fields.

Learn parameterization in LoadRunner by creating username and password parameters, pairing them in a single file, and debugging with extended logs and parameter substitution.

Demonstrates parameterization in loadrunner 12.50 by reading username and password from a single credentials file, mapping columns to parameters, choosing comma or tab delimiters, and validating iterations.

Explore parameterization in load testing by deriving username and password from a file and selecting values sequentially or randomly.

Master parameterization techniques in load testing by designing and validating test data sequences, ensuring uniqueness, and using controllers, blocks, and selectors to drive realistic test scenarios.

Learn parameterization in LoadRunner 12.50 by comparing parameter-based and function-based creation, and manage virtual users via the controller or parameter dialog for simulations.