Cartoon astronaut riding a shopping cart across a Mars-like landscape, surrounded by floating headphones, a sneaker, a game controller, a smartwatch, a shopping bag, a package, and payment cards

How to Automate Shopping Cart and Checkout Testing: A QA Specialist's Practical Guide (2026)

Liviu Lupei

Liviu Lupei

Founder & Solutions Architect, Endtest · QA specialist for ecommerce and online retail teams · November 17, 2026

By Liviu Lupei, Founder & Solutions Architect at Endtest
Published November 17, 2026 · Last updated November 17, 2026

The short answer

Automate the whole purchase, not just the form. A trustworthy checkout test starts at the cart and ends only after it has verified four things: the order exists exactly once, the payment state matches the order, the confirmation email arrived, and the invoice PDF shows the right amounts and tax.

To get there, you need to:

  1. Run your most important checkout journey in real browsers (Chrome, Firefox, Edge, and real Safari on macOS), not only in headless Linux containers.
  2. Use a tool that can handle multiple tabs, popups, and nested cross-origin payment iframes.
  3. Use your payment provider's sandbox for most payment scenarios, and add a few controlled live-payment checks.
  4. Assert business outcomes (order, payment, tax, email, invoice), not just that a success page appeared.
  5. Vary country, currency, and tax rules deliberately.

I've spent years as a QA specialist working with ecommerce and online retail companies, and these are the checks that most often separate a checkout that looks tested from one that actually is. The rest of this guide explains how to do each one.

Disclosure: Endtest publishes this article. We build and sell test automation software, and checkout testing is one of the most common ways our customers use it. I've tried to give a fair account of Selenium, Playwright, and Cypress, and to flag where each one fits.

What should an automated shopping cart and checkout test cover?

At minimum, it should verify the cart contents, pricing, address and tax calculations, payment, final order state, and customer confirmation. For a production-ready suite, you also need to cover the browser, operating system, region, and payment provider involved.

Part of the journeyWhat the automated test should verify
Add to cartThe right product, variant, quantity, and price appear
Update cartAdding, removing, and changing quantities updates totals correctly
DiscountA valid coupon applies correctly; expired or ineligible coupons fail clearly
Guest checkoutA customer can buy without creating an account, when the store allows it
Customer detailsEmail, billing address, and shipping address are retained correctly
ShippingAvailable methods, restrictions, fees, and delivery estimates reflect the address
TaxVAT, sales tax, exemptions, and rounding follow the applicable rules
PaymentThe provider opens correctly; card authentication or a redirect works
Order completionPayment and order status agree, and exactly one order is created
ConfirmationThe success page has the correct amount, currency, and order number
Email and invoiceThe email arrives and its invoice PDF contains the correct information
RecoveryAbandoned-checkout events fire, and recovery links work when applicable

Even the basket deserves real assertions. Here's the cart on endtest-demo.io, a demo store where you can practice automated tests:

Test Shop basket on endtest-demo.io showing an Automation T-Shirt at $15.99, a QA Backpack at $29.99, and a Warm Hoodie at $49.99, with a basket total of $95.97 and a Checkout button

The basket on the Endtest demo store: three items, quantity controls, Remove buttons, and a total.

A good cart test doesn't just check that three items appear. It asserts that each line price matches the catalog, that the cart badge shows 3, and that the total equals the sum of the lines ($15.99 + $29.99 + $49.99 = $95.97). Then it changes a quantity, removes an item, and asserts the total again.

You don't have to put every assertion into one enormous test. In fact, I'd avoid that. Keep a short, critical end-to-end journey and add focused tests for discounts, locations, payment failures, and other variations. But you do need at least one test that follows a real purchase all the way through.

Why a green success page isn't proof

Picture this. You buy a plane ticket. The payment screen takes a little longer than usual, then shows an error. Your banking app shows a pending card transaction. No booking confirmation arrives.

Did you buy the ticket? Should you try again? Will you be charged twice?

Now imagine being the support agent who has to check the payment provider, the order database, and the booking system, then explain the result to a worried customer. A broken product page can lose a sale. A broken checkout can lose the sale and leave a customer wondering where their money went. That's why I don't trust a couple of happy-path smoke tests here.

The most memorable checkout bug from my own QA work is a close cousin of that airline scenario. The checkout succeeded, the customer was charged, and the order was created. But every invoice was generated with a value of 0. The success page was green, the confirmation email arrived, and nothing looked wrong until someone opened the PDF. On a big online retailer's production site, the problem went undetected for about 15 minutes and affected at least 600 invoices. A test that stopped at the success page would have passed every single time, while a test that read the invoice PDF would have caught it immediately.

That wasn't a one-off. In the ecommerce and online retail projects I've tested, the same kinds of problems kept coming back:

  • A payment method failing in a browser other than Chrome, usually with an error in the console that nobody saw because the team only tested in Chrome.
  • Upsell and cross-sell items displayed incorrectly in the cart or at checkout, which quietly hurts average order value without any visible error.
  • Order emails with unresolved placeholders and missing images (more on that below).

How I triage checkout failures by business impact

Track failures by consequence, not by the number of failing assertions. This is the severity scale I'd start from:

SeverityExampleResponse
CriticalA customer is charged but no order exists, or is charged twiceStop the release, investigate immediately
HighWrong tax or total, missing confirmation email, invoice with wrong amountsFix before release
MediumA payment method appears in the wrong market, or recovery emails don't fireFix in the next cycle
LowThe promo banner shifts four pixelsLog it, batch it with other visual fixes

Why are checkout flows particularly vulnerable to cross-browser bugs?

A modern checkout is rarely one application written by one team. The cart might come from your ecommerce platform, shipping rates from another service, tax from a dedicated provider, card inputs from Stripe, Adyen, Braintree, or another processor, and a fraud service may run its own JavaScript. The confirmation email may come from yet another system.

All of this has to work in the customer's browser, where cookie policies, popup handling, tracking prevention, cross-origin frames, autofill, extensions, and third-party scripts can change the result. That creates plenty of room for browser-specific failures.

Test the checkout in actual Chrome, Firefox, Edge, and Safari, on the operating systems your customers use. For desktop coverage, that commonly means Chrome, Firefox, and Edge on Windows, plus Safari and the relevant browsers on macOS.

Why headless Linux testing isn't enough

Headless tests are fast, inexpensive, and useful in CI. But passing in a Linux container doesn't guarantee the same checkout works in a customer-facing browser on Windows or macOS. Browser builds, OS integration, font rendering, autofill, security settings, and the behavior of popups and embedded payment components can differ. Modern headless Chrome is closer to headed Chrome than older implementations were, but the environment still matters.

A practical setup uses headless CI tests for fast feedback, then runs the most important revenue-generating flows in real, headed browsers.

WebKit is not Safari

Playwright supports WebKit, and that's useful coverage. But Playwright's WebKit build is not the branded Safari browser. Playwright's own browser documentation says its WebKit build differs from Safari and recommends running WebKit on macOS for the closest Safari-like environment.

If your customers use Safari, test real Safari on macOS. We built Endtest's cross-browser testing around real browser execution on Windows and macOS, including actual Safari. For critical checkout journeys, that difference matters.

Here's a real example of why this matters. On a checkout I tested, the Pay button never became active in Safari after the customer filled in their credit card details. In other browsers, the button activated as soon as the card details were complete. In Safari it stayed disabled, so Safari customers couldn't pay at all, and nothing on the page explained why. A Chrome-only run, or a headless run, would never have shown it.

Why do payment flows require multiple-tab testing?

Not every payment stays inside the checkout page. Some methods redirect to a bank. Some open a new tab or popup. An authentication page may ask the customer to approve a transaction, then return control to the store. Other checkouts open invoices or receipts in a separate tab.

A proper test follows that path instead of stopping when the original page opens something else. For a payment that launches a new tab:

  1. Add a product and proceed to checkout.
  2. Choose the payment method.
  3. Confirm that the provider's tab opens.
  4. Switch to it, complete the test authentication or payment flow, and return to the original tab.
  5. Verify that the shop recognizes the result and creates the correct order.

If your automation tool can't work with the second tab, it's tempting to skip the most interesting part of the test.

Is Cypress a good choice for checkout automation?

It's possible to test checkouts with Cypress, but it wouldn't be my first choice for complicated third-party payment journeys.

Cypress runs its main test in one tab. As its multi-tab guide explains, the @cypress/puppeteer plugin can reach other tabs and popups, but that introduces a separate automation mechanism, and the plugin's coverage is limited to Chromium-based browsers. That's a meaningful trade-off if the problem you're trying to catch involves payment popups across several browsers.

Endtest supports switching between browser tabs directly in its test steps. Selenium and Playwright also have native ways of handling tabs and windows, although you maintain the supporting code and infrastructure.

How do you automate credit card fields inside nested iframes?

The card number input on the page often isn't an ordinary input owned by your website. Payment processors commonly embed card fields in an iframe from their own domain, and depending on the integration, a field may sit inside a second iframe nested within the first. That's intentional: hosted payment fields can reduce the card data the merchant handles directly, depending on the integration and compliance scope.

But automation has to enter the right frame before it can interact with the field. A test may need to:

  1. Locate the outer payment iframe and switch into it.
  2. Locate an inner iframe for the card number, expiration date, or security code.
  3. Enter the payment provider's approved test data.
  4. Return to the parent document and submit the payment.
  5. Handle a possible 3-D Secure (3DS) challenge, redirect, or confirmation.

A tool that can find a normal input but can't switch through nested frames isn't enough.

This is another place where Cypress can be awkward. Its documentation explains that normal Cypress commands cannot automate embedded cross-origin iframes, including common hosted card forms. Same-origin iframes are different, and there are workarounds for some Chromium configurations, but they aren't equivalent to ordinary cross-browser iframe support.

Endtest has documented support for nested iframes, which helps when the checkout includes hosted card fields, identity verification, or embedded third-party widgets.

Should checkout automation use real payments or dummy credit cards?

For your most important tests, reach a completed order. Filling the card fields and clicking Pay is only part of the journey.

People sometimes paste a recognizable test number such as 4111 1111 1111 1111 into the form and assume they've tested payment. In a live environment, that isn't a usable card. It may pass front-end formatting or checksum checks, but it can't prove a real transaction can settle.

In a payment provider's sandbox or test mode, that provider's documented test cards can simulate successful payments, failures, and authentication flows. This is the right way to automate most payment scenarios without moving real money. Use the specific numbers and methods your provider documents, rather than assuming any fake card works everywhere.

ApproachWhat it provesWhat it doesn't prove
Payment-provider test modeThe app handles simulated authorization, rejection, and 3DS outcomesA real production charge will succeed
One-time 100% discount couponA zero-total checkout can create an order and trigger confirmation workflowsThe external card processor actually charged anything
Large discount plus an authorized company cardA controlled live checkout can exercise a real paymentEvery payment method, edge case, or production incident

The 100% coupon technique is especially practical. Your test can generate a unique, single-use coupon, apply it, complete the free checkout, and verify the order, email, and invoice. Just don't mistake it for proof that card payments work: a zero-total order may bypass the processor altogether.

For an occasional live payment check, you might issue a 99.9% discount and charge the remainder to an approved company card. Make sure the amount meets the provider's minimum charge, that taxes and rounding are understood, and that finance has approved how the transaction, refund, and bookkeeping are handled. A tiny charge isn't automatically something you can write off.

My approach: sandbox payments frequently, free-order checks when useful, and a small number of controlled live-payment checks where the risk justifies them.

Test what happens when a payment fails, too

A successful transaction is only half the story. Also test declined cards, timeouts, interrupted 3DS authentication, browser back-navigation, and repeated clicks on Pay.

The most expensive bugs aren't always failed charges. They're successful charges attached to missing orders, or duplicate charges caused by retries. A good test checks the payment provider's state and the order database, not just the text on the confirmation page.

For integrations that use payment webhooks, test delayed, duplicate, and out-of-order notifications. Your system should handle retries without creating a second order or fulfilling the same purchase twice.

How do you test abandoned-cart and abandoned-checkout events?

Many teams forget this one. A customer adds something to the cart, starts a guest checkout, enters an email address, and leaves. Can your store still send an appropriate reminder?

You'll see this called abandoned-cart tracking, abandoned-checkout events, or checkout recovery automations. Some applications implement it with backend hooks or webhooks, but cart hooks isn't a universal name.

For guest checkout, entering an email is often the moment a store can associate an otherwise anonymous cart with a contact. If the front end fails to save that email or notify the backend, the recovery system has nothing to work with. An automated test should verify that:

  • The email and checkout identifier are saved or sent to the backend at the intended step.
  • The cart contents and recovery link are associated with the correct checkout.
  • Leaving before purchase marks the checkout as abandoned according to the application's rules.
  • An eligible test recipient receives the recovery message and can resume the correct cart.
  • Completing the order suppresses unnecessary recovery reminders.

Also verify consent and marketing eligibility rather than assuming every visitor can legally be emailed. Even Shopify's abandoned-checkout automations have eligibility and delivery rules. These aren't just marketing tests. They check that the store hasn't quietly lost the ability to recover revenue.

Why should you test checkout emails and PDF invoices?

Because the customer doesn't experience the checkout as finished when your test sees a green success page. They expect an email. They may need the invoice for expenses or accounting. In an airline or event-ticketing flow, that email may be the document they need to travel or enter.

Verify the confirmation email's recipient, order number, item details, amount, currency, and the link back to the order. Then verify the invoice itself.

Don't stop at checking that a PDF exists. Open it or extract its content and check the invoice number, date, seller details, customer details, items, taxes, currency, totals, and any fields legally required in your jurisdiction. It's surprisingly easy to send an email with the right total and attach an outdated invoice with the wrong billing address or tax rate.

The four-way amount check

For every money-related test, I reconcile the same total in four places:

  1. The checkout page the customer saw
  2. The order record in your system
  3. The amount captured by the payment provider
  4. The invoice PDF

If any one of these disagrees, you've found a bug that no screenshot comparison would have caught.

How Endtest handles email and PDF verification

Endtest Mailbox provides disposable test inboxes at @endtest-mail.io. You can use one as the customer's email address, complete the checkout, and inspect the message from the automated test. The inboxes are temporary, which makes them appropriate for synthetic test data, not real customer communication.

Endtest also documents testing email workflows, file downloads, and extracting or validating PDF contents, so the test can go beyond "Email sent" and examine what the customer actually receives. Where a PDF arrives as an email attachment, plan an attachment-download or retrieval step before PDF validation.

Real email bugs I've seen

Two failures keep showing up in order emails, and both are easy to assert on once you know to look:

  • Unresolved template variables. We once received an email that greeted the customer with a literal Hi $FirstName instead of their actual first name. The email was "sent", so a simple delivery check passed. Assert that no raw placeholder syntax ($FirstName, {{first_name}}, %NAME%) remains in the subject or body, and that the name matches the one entered at checkout.
  • Missing product images. In several cases, the product images didn't display in the email. Check that each image in the message actually loads, not just that an <img> tag exists.

How do you test checkout flows in different countries?

Run the checkout as customers in different countries experience it, not just as a user who changes the country dropdown. A store may use the IP address, shipping country, billing country, currency, browser language, or merchant configuration to decide what to display. Those signals can disagree, so test them deliberately.

Germany: review the order before committing to pay

Germany shows why localization goes beyond translating buttons. Under Section 312j of the German Civil Code (BGB), consumer checkouts subject to the provision must prominently present specified order information immediately before the customer places the order. The order button must also make the payment obligation unambiguous, using wording such as "zahlungspflichtig bestellen" or another sufficiently clear equivalent.

Many stores implement this with a Review order step where customers check the product, quantity, price, shipping charges, and other details. The law doesn't necessarily require a separate page literally called "Review," but your test should verify the required information and the final confirmation behavior.

Payment methods differ by market

A checkout aimed at Dutch customers may offer iDEAL, a Belgian one Bancontact, and a Polish one BLIK. Availability depends on the provider, merchant account, currency, and configuration, so don't hardcode assumptions without checking your integration. Confirm both sides of the rule: appropriate methods appear for eligible customers, and unavailable methods don't appear in other markets.

Endtest geolocation testing can vary HTML5 location or regional IP routing, which is more realistic than relying on a language dropdown alone. Remember that shipping and billing test data may need to change too.

How do you verify VAT, sales tax, and currency calculations?

A checkout tax mistake can become a refund problem, a customer complaint, an accounting problem, and sometimes a legal one.

A common mistake is applying the store's domestic VAT rate to every international customer. For example, an EU merchant generally shouldn't automatically charge domestic VAT on qualifying exports of goods to the United States. The European Commission explains that qualifying exports outside the EU are VAT-exempt under the relevant rules. But correct treatment depends on the product, where the supply takes place, the buyer, and the transaction, and US state sales-tax obligations may still exist.

So don't test a simplistic rule like "US customer = no tax anywhere." Test what your tax configuration is actually supposed to do. Useful cases include:

  • Domestic orders
  • EU cross-border orders, where relevant
  • Non-EU exports
  • Tax-exempt buyers
  • Differing shipping and billing countries
  • Tax-inclusive vs. tax-exclusive prices
  • Rounding when discounts are applied

Check amounts with the four-way reconciliation above. If your checkout converts currencies, also check that labels and amounts aren't mixed. Charging $100 while displaying €100 is not a minor visual bug.

Why is visual testing especially important for checkout pages?

A checkout has to work correctly and look trustworthy. Suppose the card field overlaps the expiration date, a discount message covers the Pay button, or the payment iframe leaves a strange blank gap. The customer may not think "scam," but they may wonder how careful the company is with their payment details. That's a reasonable reaction even when the underlying payment security is sound.

Use visual regression tests for the cart, order review, payment area, error messages, and success page. Run them at important desktop and mobile viewport sizes, and keep separate baselines where browsers render differently. Pair screenshot comparisons with functional assertions: a beautiful checkout that double-charges customers is still broken.

Endtest's Visual AI compares pages or individual elements against baseline screenshots and highlights changes. For checkout, focus it on the areas customers look at when deciding whether to trust the form.

Do Shopify and other hosted ecommerce platforms still need testing?

Yes. Shopify, WooCommerce, Magento/Adobe Commerce, and similar platforms remove a lot of work, but not your responsibility for the customer journey.

Most stores don't run an untouched default theme forever. They install apps, customize templates, add promotions, connect payment methods, change shipping rules, and insert third-party JavaScript. Someone updates a theme or plugin, a payment provider changes an integration, or Chrome ships a new version. Any of those can expose a problem that wasn't there last week.

The right question isn't whether the platform's checkout has been tested by the vendor. It's whether your store's specific combination of theme, apps, configuration, regional rules, and payment integrations still works. If part of the checkout is hosted and not customizable, focus on the integration boundaries: what gets passed in, how payment returns, what order gets created, and what the buyer receives.

Which tools are suitable for checkout test automation?

ToolWhere it fitsCheckout-related trade-off
EndtestTeams that want no-code and AI-assisted tests in real browsers on Windows and macOSCommercial platform; tests are maintained as editable steps rather than in a code repository
SeleniumEngineering teams that want broad browser control and own their infrastructureFramework, browser grid, drivers, test code, and maintenance are your responsibility
PlaywrightCode-first teams that want strong handling of frames, tabs, and browser contextsIts WebKit browser is not branded Safari; real Safari needs another solution
CypressTeams focused on app flows that mostly stay in one tab and avoid cross-origin framesMulti-tab flows need extra tooling; cross-origin payment iframes are a documented limitation

For checkout specifically, I weigh real browser coverage, nested iframe support, multiple tabs, and email/PDF verification more heavily than how quickly a tool can click Add to Cart.

How Endtest approaches checkout testing

Endtest customers automate purchase flows across large online retailers, airlines, online services, and smaller businesses. The details differ, but the problems repeat: payment providers, browser differences, complicated checkout forms, and the need to verify that a transaction really finished. That has shaped what we built.

Teams can create readable, editable test steps, use AI-assisted test creation, run across real browsers on Windows and macOS, switch tabs, work inside nested iframes, vary geolocation, inspect emails, validate PDFs, and compare screenshots. Self-healing can reduce some maintenance when locators change. Tests can also connect to CI/CD and run on a schedule.

The point isn't that every checkout needs AI. It's that the test should follow a real customer journey without turning each new payment integration into weeks of framework work.

What would a practical checkout regression suite look like?

If I were starting from scratch, I wouldn't try to automate every product and payment combination on day one. I'd build in roughly this order:

  1. A complete guest purchase: add one product, check totals, complete a sandbox payment, confirm the order, verify the email and invoice.
  2. A real-browser matrix: the same core checkout in Chrome, Firefox, Edge, and real Safari, on Windows and macOS where relevant.
  3. Hosted payment fields and authentication: nested iframes, bank redirects, popups, extra tabs, 3DS success and cancellation.
  4. Money calculations: coupons, shipping, VAT or sales tax, currency, rounding, and refunds.
  5. Recovery and failure cases: declined payment, backend timeout, retry, duplicate Pay clicks, abandoned checkout, and order creation after delayed payment webhooks.
  6. Visual and responsive checks: key viewport sizes, payment forms, error states, and the success page.
  7. Country-specific cases: markets with different checkout rules, tax rules, or locally popular payment methods.

Run the fast, stable checks on every change. Run the broader real-browser and regional matrix on a schedule and before important releases. Use controlled production smoke tests for the few things staging can't prove.

The step I see teams skip most often is step 1's actual payment. Many teams never complete a real payment in their automated tests. They don't want to deal with getting a company credit card, or with building logic that generates a one-time 99.9% discount coupon. My guess is that the team or the manager assumes it's much harder than it really is. It isn't. A unique single-use coupon and an approved company card are usually a small amount of work compared with what a bug like the zero-value invoices above can cost.

Frequently asked questions

What is shopping cart testing?

Shopping cart testing verifies that customers can add, remove, and update products and that quantities, prices, discounts, and totals stay correct. Checkout testing extends that through customer details, shipping, tax, payment, order completion, and confirmation.

What is the best way to automate a checkout flow?

Start with a full guest checkout using synthetic customer data and your payment provider's test environment. Verify the final order and email, not just the success screen. Then add the browsers, regions, payment types, and failure scenarios that matter to your business.

Can Playwright test checkout pages in Safari?

Playwright can run WebKit, which is valuable Safari-related engine coverage, but it does not automate the branded Safari browser with its bundled WebKit build. To verify real Safari, use a solution that runs actual Safari on macOS, such as a Safari WebDriver setup or a real-browser testing platform.

Can Cypress test payment iframes and multiple tabs?

Cypress can test many checkout flows, and its Puppeteer plugin can handle multiple tabs in Chromium-based browsers. However, its normal commands cannot directly automate cross-origin payment iframes, which makes complicated third-party payment journeys harder to cover consistently across browsers.

Can you automate a checkout without charging a real credit card?

Yes. Use a payment provider's sandbox to simulate approved and declined transactions. A one-time 100% discount coupon can also test zero-value order creation, emails, and invoices, but it doesn't validate a real card charge. Controlled low-value live transactions are an additional option when approved and properly reconciled.

Should you automate shopping cart abandonment emails?

Yes, when they're part of the store's workflow. Verify that checkout records the email and cart correctly, that eligible users receive the recovery message, and that completing the order prevents unnecessary reminders. Respect consent and marketing rules.

Does a Shopify store need automated checkout tests?

Yes. Themes, apps, custom code, payment providers, tax settings, and browser updates can affect your store even when the underlying platform is widely used. Test your actual configured customer journey.

What is the best test automation tool for checkout flows?

For teams with a mature code-first stack, Selenium or Playwright can be good options. For teams that want real Safari and other desktop browsers, native handling of tabs and iframes, email/PDF checks, and less automation maintenance, Endtest is a strong fit.

The bottom line

Checkout automation doesn't need to be complicated, but it does need to be complete. The goal isn't to prove the Pay button can be clicked. It's to prove that a customer can choose something, pay the right amount, receive what they bought, and walk away with a clear confirmation of what happened.

That includes the awkward parts: a popup from a bank, a card field inside two iframes, Safari behaving differently from Chrome, a German order-review requirement, an invoice with the wrong tax, or a payment that succeeds while the order fails. Those are exactly the problems a shallow smoke test misses, and exactly the problems that make customers ask support an uncomfortable question: "Did you take my money?"

Start with one end-to-end purchase and make it trustworthy. Then expand by browser, payment provider, and country. Endtest can help you do that without maintaining the browser automation stack yourself.

Sources and further reading

About the author

Liviu Lupei is the founder of Endtest and a Solutions Architect with 15 years of experience in Quality Assurance. Before and alongside building Endtest, he worked as a QA specialist for several ecommerce and online retail companies, testing real carts, checkouts, and payment flows, and has since worked with teams automating complex web application workflows, including ecommerce and payment journeys.

Connect with Liviu on LinkedIn or read more of his writing on Medium.

Last updated: November 17, 2026.

Get started with Endtest today!

Create your first test in minutes, with nothing to install. Build fast, maintainable test suites without writing a line of code.