DZone Testing, Tools, and Frameworks Zone

Does 100% Code Coverage Mean Tested?

Stelios Manioudakis — Wed, 15 Jul 2026 13:00:00 GMT

There is a number that engineering organizations love to report, and that engineering leaders love to receive: 100% code coverage. It has the satisfying quality of completeness. But completeness of what exactly? It implies that every line has been tested, every branch examined, every condition verified. It looks like the mathematical proof of a job well done. It is not, however. And the gap between what that number promises and what it delivers is, in many organizations, the single most expensive misunderstanding in the quality program.

Code coverage measures the proportion of code that tests execute, not the proportion of behavior that tests verify. These are profoundly different things, and conflating them produces systems that are well-covered, yet dangerously under-tested. The engineers know the coverage number. The executives trust the coverage number. And the system fails in ways that the coverage number was incapable of detecting.

Do We Test Just to Find Bugs?

Stelios Manioudakis — Tue, 14 Jul 2026 16:00:00 GMT

In a world where testing is mainly test execution, it is reasonable to expect that when people test, they simply expect to find bugs. "We test to find bugs" is the answer given in job interviews. An answer repeated in onboarding materials, embedded in KPI frameworks, and implicitly assumed in every conversation about when software is ready to ship. It is so thoroughly taken for granted that questioning it sounds absurd, like questioning whether hammers are for hitting things.

Testing does find bugs since it involves test execution. But testing involves much more than execution. Framing testing as just a bug-finding activity results in a number of consequences that this article will discuss.

AWS Glue ETL Design Principles for Production PySpark Pipelines

Janani Annur Thiruvengadam — Tue, 14 Jul 2026 14:00:00 GMT

AWS Glue makes it easy to get a PySpark pipeline running quickly. It is significantly harder to build one that stays maintainable as logic grows, performs reliably at scale, and does not quietly accumulate operational debt over time.

Most Glue pipelines start simple and become difficult to manage gradually — formulas get hardcoded, modules grow without boundaries, output files proliferate, and before long a single job is doing too many things in ways that are hard to test, hard to debug, and expensive to change.

Performance Testing RAG Applications: Complete Engineering Guide

NaveenKumar Namachivayam — Mon, 13 Jul 2026 15:00:00 GMT

In this blog post, we will see how to perform a performance test on a retrieval-augmented generation (RAG) application properly, covering both speed and correctness, and how to wire both into a CI/CD pipeline so regressions get caught before they reach production.

Performance testing a RAG application requires two separate testing gates: one for speed and one for answer quality. Traditional load testing tools measure response times but cannot detect hallucinations, where a model returns fast but factually incorrect answers grounded in fabricated context rather than retrieved documents.

Azure Databricks vs Microsoft Fabric: An Honest Guide to When to Use What

Jubin Abhishek Soni — Thu, 09 Jul 2026 12:00:07 GMT

If you're building a data platform on Azure in 2026, you're going to be asked this question: Azure Databricks or Microsoft Fabric? Both run on Delta Lake, both integrate with ADLS Gen2, both have Spark, and both promise to be your unified data platform. The overlap is real, and the marketing doesn't help.

This post is an honest breakdown of where each genuinely excels, where they overlap, and how to decide without getting lost in feature comparison tables.

Reading Playwright Traces When Browser Automation Fails

Cornelius Renken — Wed, 08 Jul 2026 15:00:00 GMT

One error message has been haunting me since I started working with Playwright for browser automation: "Target page, context, or browser has been closed."

At first it seemed actionable, so I went hunting for where it got closed and what closed it. But I didn't find the cause, and it only happened once, so I moved on. The same message turned up two days later from an unrelated cause. This time I was certain I could find the issue. I dove into the infrastructure logs, comparing the failure from two days ago with today's. The first time, a load balancer dropped an idle browser connection after a timeout nobody had documented. The second time, our own cookie-consent-handling code was closing a tab it shouldn't touch. One error string, two completely unrelated issues.

How We Know What We Know

Stelios Manioudakis — Tue, 07 Jul 2026 16:00:00 GMT

In 1936, a mathematician named Alan Turing asked one of the most consequential questions in the history of computing: Can a machine think? The question has become especially popular nowadays with the development of AI. But before Turing would answer it, he had to answer a harder question: how would we know? What would count as evidence? His answer — the Turing test — was not a definition of intelligence. It was a framework for generating evidence. The question was epistemological before it was technical. It concerned not the question itself, but how we come to know an answer.

Software testing is the same kind of problem.

Azure Databricks for Scalable MLOps and Feature Engineering With Apache Spark, Delta Lake, and MLflow

Jubin Abhishek Soni — Mon, 06 Jul 2026 14:00:03 GMT

Raw data doesn't win model competitions. Features do. And when your raw data is tens of billions of rows sitting across multiple sources, you can't afford to run pandas in a notebook and call it a day.

In this tutorial, I'll walk through building a production-grade feature engineering pipeline on Azure Databricks using:

Why AI-Generated Code Is Making Regression Testing More Important, Not Less

Sancharini Panda — Wed, 01 Jul 2026 16:00:00 GMT

There is a widespread assumption circulating in engineering teams right now that goes something like this: if AI can write code faster, it probably makes testing less of a bottleneck too. The logic seems reasonable on the surface. Faster code, faster tests, faster everything.

This assumption is wrong, and teams that act on it are going to find out the hard way.

Can Rust Have Zero-Cost Dependency Injection?

Dmytro Brazhnyk — Wed, 01 Jul 2026 15:00:04 GMT

Overview

This article explores whether dependency injection (DI) can exist in Rust without sacrificing the language’s core philosophy of zero-cost abstractions.

We will approach the question from three angles:

Selective Deployment in Azure Data Factory: A Practical Blueprint for Safer CI/CD

Sauhard Bhatt — Fri, 26 Jun 2026 17:00:03 GMT

Picture this: two features are being developed in parallel.

One has already been tested in lower environments, but is still awaiting business approval
The other is fully validated and ready to go live

Naturally, you want to release the second feature to production.

REST-Assured Configuration and Specifications: Writing Maintainable API Tests

Faisal Khatri — Thu, 25 Jun 2026 13:00:12 GMT

When working on API automation projects, one of the first things that becomes repetitive is configuring the same settings for every test. The base URL, content type, request logging, and common response validations often appear in multiple test classes. As the number of tests increases, maintaining these repeated configurations becomes difficult.

REST Assured provides specifications to solve this problem. Instead of defining the same settings in every test, common configurations and specifications can be created once and reused throughout the test suite.

Implementing Asynchronous Communication Between Microservices Using Kafka and Spring Boot

Mallikharjuna Manepalli — Wed, 24 Jun 2026 13:00:05 GMT

In a microservices system, that tight coupling turns a small hiccup into a cascading slowdown. Thread pools fill, retries amplify traffic, and suddenly your simple request is blocked on half the fleet. My executive summary: asynchronous messaging with Kafka helps systems keep moving when individual components inevitably slow down or fail. It does this by decoupling producers from consumers, absorbing traffic spikes, and allowing services to evolve without tying their availability directly to one another.

Code Patterns in Spring Boot With Kafka

Spring for Apache Kafka gives me two primitives that feel pleasantly old Spring KafkaTemplate for sending and @KafkaListener for receiving. That template/listener model is intentionally similar to other Spring integration tech, which keeps application code focused on domain logic instead of raw client plumbing.

I Built a VS Code Extension to Debug Azure AI Foundry Agents Without Leaving My Editor

Jubin Abhishek Soni — Tue, 23 Jun 2026 14:00:00 GMT

The Problem

Azure AI Foundry has a genuinely great portal. You can see your agent runs, the tools it calls, the messages it sends and receives, and even a breakdown of token usage — all in a clean UI.

But here's what actually happens when you're building an agent locally:

Testing Strategies for Web Development Code Generated by LLMs

Sandesh Basrur — Fri, 19 Jun 2026 17:00:00 GMT

Large Language Models (LLMs) can automate the development process by producing a substantial amount of web application code in just a few minutes. Nonetheless, it is important to bear in mind that these models are pattern-based and not deterministic.

Work in the domain of AI programming assistants shows that AI-based code often exhibits security vulnerabilities in real-world testing. A study on GitHub's features showed that approximately 40% of the generated code was susceptible to security issues, emphasizing the need for careful testing and scrutiny.

On-Device Debugging and JUnit 5

Shai Almog — Wed, 17 Jun 2026 15:00:00 GMT

This is the first follow-up to Friday's release post, and it covers the two changes from this release that affect how you iterate on a Codename One app rather than what the app itself does. On-device debugging that treats Java as Java on a real iPhone or a real Android device, and standard JUnit 5 against the JavaSE simulator. The first is the one we have been wanting for a long time, and is the one that takes the most explaining, so most of the post is about it.

On-Device Debugging That Treats Java as Java

Codename One has always supported on-device debugging in the strict technical sense. You could attach Xcode to a .ipa, you could attach Android Studio to a running APK, you could read the native call stack, you could step through Objective-C or the C that ParparVM emits. What you could not do was set a breakpoint in MyForm.java, hit it on a real iPhone, and inspect a Java field on a Java object as a Java object. You also could not debug an iOS app without a Mac in the loop somewhere, because the only debugger that understood the binary was Xcode. The translation step between the Java you wrote and the C that ParparVM produces left no way back across the gap on the device.

Testing Is Not About Finding Bugs

Abhinav Garg — Wed, 17 Jun 2026 12:00:00 GMT

One of the most common statements we hear in the software industry is:

"The job of a tester is to find bugs."

Getting Started With GitHub Copilot CLI for Coding Tasks

Gunter Rotsaert — Tue, 16 Jun 2026 14:30:00 GMT

Nowadays, there are quite a lot of AI coding assistants. In this blog, you will take a closer look at GitHub Code CLI, a terminal-based AI coding assistant. GitHub Copilot CLI integrates smoothly with GitHub Copilot, so if you have a GitHub Copilot subscription, it is definitely worth looking at. Enjoy!

Introduction

There are many AI models and also many AI coding assistants. Which one to choose is a hard question. It also depends on whether you run the models locally or in the cloud. When running locally, Qwen3-Coder is a very good AI model to be used for programming tasks. In previous posts, DevoxxGenie, a JetBrains IDE plugin, was often used as an AI coding assistant. DevoxxGenie is nicely integrated within the JetBrains IDE's. But it is also a good thing to take a look at other AI coding assistants. In previous blogs, Qwen Code and Claude Code were used in combination with local models.

Building a RAG-Powered Bug Triage Agent With AWS Bedrock and OpenSearch k-NN

Rajasekhar sunkara — Tue, 09 Jun 2026 16:00:00 GMT

Bug triage on a graphics engineering team is one of those tasks nobody really wants to own. A new crash report comes in, and somebody has to work out whether it looks like a known issue, what the stack trace points at, which subsystem the affected code lives in, and which sub-team should pick it up. The answers exist in the issue tracker, the source repo, and the architecture docs, but pulling them together by hand takes time. And the engineers best at it are the ones you least want spending hours on it.

On our team, the archive of resolved bugs had grown to over 1,100 issues. That is a real corpus. It contains the answer to a lot of incoming questions, but only if you can find the right three or four entries quickly. The agent described here does that lookup automatically, combines it with crash log parsing and source code search, and produces a root cause analysis with a confidence score. Triage that used to take hours now takes minutes.

Frame Buffer Hashing for Visual Regression on Embedded Devices

Rajasekhar sunkara — Tue, 09 Jun 2026 15:00:00 GMT

I run test automation for a graphics team that ships software to streaming devices. About a year ago, we changed how our visual regression suite stores and compares its references. The old approach kept around 18GB of PNG golden images in the test repo and ran a pixel-by-pixel diff on every comparison. The new approach stores around 19KB of MD5 hashes in a JSON file and compares hash strings. Storage dropped by roughly three orders of magnitude. Comparisons became effectively free. A category of flaky tests stopped being flaky.

This article is about how that works, when it makes sense, and when it doesn't. It also covers the parts that surprised me, because the approach has real downsides and I want to be honest about them up front.