MSDN Magazine: Test / Debug rss

All MSDN Magazine Topics
  • Patterns in Practice: Incremental Delivery Through Continuous Design
    Jeremy Miller - August 2009
    The end goal of software projects is to deliver value to the customer. Software design is a major factor in how successfully a team can deliver that value. The best designs are a product of continuous design rather than the result of an effort that tries to get the entire design right up front. This approach lets you strive to apply lessons learned from the project to continuously improve the design, instead of becoming locked into an erroneous design developed too early in the project.

  • Usability in Practice: Usability Testing
    Dr. Charles B. Kreitzberg and Ambrose Little - July 2009
    This month's column describes the benefits and methodologies of usability testing.

  • Test Run: Request-Response Testing With F#
    James McCaffrey - July 2009
    This month we show you how to use F# to perform HTTP request-response testing for ASP.NET Web applications.

  • Test-Driven Design: Using Mocks And Tests To Design Role-Based Objects
    Isaiah Perumalla - June 2009
    Use Test-Driven Development with mock objects to design object oriented code in terms of roles and responsibilities, not categorization of objects into class hierarchies.

  • Usability in Practice: Agile Ux Development
    Dr. Charles B. Kreitzberg and Ambrose Little - June 2009
    This month the authors show you how to treat the user experience as an essential dimension of the development process while retaining the advantages of Agile.

  • Test Run: .NET Module Testing with IronPython
    James McCaffrey - June 2009
    This month we demonstrate how easy it is to use IronPython to test .NET-based libraries.

  • Test Run: Automating UI Tests In WPF Applications
    James McCaffrey - March 2009
    This month we describe techniques for automating UI testing in Windows Presentation Foundation applications.

  • .NET Interop: Getting Started With IronRuby And RSpec, Part 1
    Ben Hall - February 2009
    See how IronRuby lets you employ the straightforward Ruby language to create acceptance tests that interoperate with .NET-compliant code.

  • Test Run: Analyzing Project Exposure And Risk Using PERIL
    Dr. James McCaffrey - January 2009
    Here James McCaffrey uses some statistical methods and a technique he calls PERIL to estimate risks to software projects involving timing, costs, and other potential resource shortfalls.

  • Patterns in Practice: Design For Testability
    Jeremy Miller - December 2008
    Designing testability into your app means smaller tests that are cheaper to create, easier to understand, faster to run, and much simpler to debug.

  • Test Run: Configuration Testing With Virtual Server, Part 2
    Dr. James McCaffrey and Paul Despe - December 2008
    Because Virtual Server is built upon a set of COM modules, you can automate the creation and testing of virtual machines. Here we use Windows PowerShell to run the tests.

  • { End Bracket }: What Makes A Good Software Tester?
    Dr. James McCaffrey - December 2008
    In this month's installment, James McCaffrey talks about the qualities and skills he looks for when searching for great software testers.

  • Test Run: Group Determination In Software Testing
    Dr. James McCaffrey - November 2008
    There is a large body of research on group techniques to determine the best alternative from a set of options. Dr. James McCaffrey outlines five of them.

  • Concurrency Hazards: Solving 11 Likely Problems In Your Multithreaded Code
    Joe Duffy - October 2008
    Here we describe some of the more common challenges to concurrent programming and present advice for coping with them in your software.

  • Toolbox: Realistic Test Data, Dare Obasanjo’s Blog, Color-Coding Tools, and More
    Scott Mitchell - October 2008
    This month Scott shows how to generate realistic test data, visits Dare Obasanjo's blog, and demonstrates color coding code for better readability.

  • Test Run: Configuration Testing With Virtual Server, Part 1
    Dr. James McCaffrey - September 2008
    This time James McCaffrey sets up a virtual environment to use for configuration testing to introduce you to software configuration testing with Microsoft Virtual Server

  • Test Run: Introduction to WCF Testing
    Dr. James McCaffrey - July 2008
    This month James McCaffrey builds a test harness for WCF applications that really puts them through the paces.

  • Security Briefs: Reinvigorate your Threat Modeling Process
    Adam Shostack - July 2008
    In this column the author outlines some approaches to threat modeling that can be employed by development teams of any size.

  • Toolbox: Cross Browser Testing, Mock Objects, and Raymond Chen
    Scott Mitchell - June 2008
    This month test your web site on many platforms and browsers without setting up a test environment, use mock objects for unit testing, and visit Raymond Chen.

  • CLR Inside Out: Measure Early and Often for Performance, Part 2
    Vance Morrison - May 2008
    In the second of a two-part series, Vance Morrison delves into the meaning of performance measurements, explaining what the numbers mean to you.

  • Security Briefs: Penetration Testing
    James A. Whittaker - May 2008
    In this installment of Security Briefs, James Whittaker explains the rules and the pitfalls of penetration testing so you'll know how to avoid them.

  • CLR Inside Out: Measure Early and Often for Performance, Part 1
    Vance Morrison - April 2008
    In this month’s column, get the inside scoop on how to build performance into your apps from the start, rather than dealing with the fallout after you deploy them.

  • Test Run: Testing SQL Stored Procedures Using LINQ
    Dr. James McCaffrey - April 2008
    Language Integrated Query makes lots of things easier. Here we put LINQ, or more specifically the LINQ to SQL provider, to use testing SQL stored procedures.

  • ASP.NET MVC: Building Web Apps without Web Forms
    Chris Tavares - March 2008
    Chris Tavares explains how the ASP.NET MVC Framework's Model View Controller pattern helps you build flexible, easily tested Web applications.

  • Loosen Up: Tame Your Software Dependencies for More Flexible Apps
    James Kovacs - March 2008
    James Kovacs explains the dark side of tightly coupled architectures, why they're hard to test and how they limit adaptation. He then proposes a number of solutions.

  • CI Server: Redefine Your Build Process with Continuous Integration
    Jay Flowers - March 2008
    Jay Flowers demonstrates how to set up and use a Continuous Integration server using both discrete tools and the more comprehensive CI Factory solution.

  • Performance: Find Application Bottlenecks with Visual Studio Profiler
    Hari Pulapaka and Boris Vidolov - March 2008
    We will introduce you to the Visual Studio Profiler by walking through a sample performance investigation, pinpointing code inefficiencies in some sample applications.

  • Test Run: Web UI Automation with Windows PowerShell
    Dr. James McCaffrey - March 2008
    Here we show you how to use Windows PowerShell to create quick and easy UI test automation for ASP.NET and classic ASP Web applications.

  • WinUnit: Simplified Unit Testing for Native C++ Applications
    Maria Blees - February 2008
    Maria Blees introduces WinUnit, a handy new unit testing tool for native C++ projects.

  • Toolbox: Powerful Text Editing, Web Testing in .NET, Extended Unit Testing, and More
    James Avery - February 2008
    Powerful Text Editing, Web Testing in .NET, Extended Unit Testing, and More

  • Test Run: The Microsoft UI Automation Library
    Dr. James McCaffrey - February 2008
    James McCaffrey shows you how to get started with UI test automation using the new Microsoft UI Automation library.

  • Test Run: UI Automation with Windows PowerShell
    Dr. James McCaffrey - December 2007
    This installment of Test Run is a guide to using Windows PowerShell to perform ultra lightweight UI automation.

  • Fuzz Testing: Create a Custom Test Interface Provider for Team System
    Dan Griffin - November 2007
    Dan Griffin shows the extensibility of Visual Studio 2005 Team Edition for Software Testers by discussing the modification of the existing Test Interface Provider sample in the latest Visual Studio SDK and implements Fuzz Testing.

  • Bugslayer: Measuring the Impact of View State
    John Robbins - November 2007
    Bloated view state can be a real performance bottleneck for your Web app, but it can be difficult to diagnose. John Robbins creates a handy tool that records and reports the view state size for pages in your ASP.NET applications.

  • .NET Matters: Debugging finalizers
    Stephen Toub - November 2007
    Find out how to use finalizers as a way to warn developers who use your custom types when they are garbage collected without having been disposed of correctly.

  • Test Run: Test automation with Windows XP Embedded
    Dr. James McCaffrey and Mike Hall - October 2007
    This month's column explores how to create lightweight but powerful UI test automation for software systems that run on Windows XP Embedded.

  • Unit Testing: Exploring The Continuum Of Test Doubles
    Mark Seemann - September 2007
    Creating and using mock component servers simplifies unit testing. Use these examples to get started.

  • Bugslayer: Wait Chain Traversal
    John Robbins - July 2007
    Windows Vista has a new API called Wait Chain Traversal (WCT), which allows you to determine when and why a process is deadlocked. Read on.

  • Test Run: Lightweight Testing with Windows PowerShell
    Dr. James McCaffrey - May 2007

  • Event Tracing: Improve Debugging And Performance Tuning With ETW
    Dr. Insung Park and Ricky Buch - April 2007
    Event Tracing for Windows (ETW) provides general-purpose, high-speed tracing of events raised by both user-mode applications and kernel-mode device drivers. Learn how ETW can improve your development and debugging work.

  • Test Run: Testing Custom Transform Streams
    Dr. James McCaffrey - March 2007

  • Bugslayer: GUI Control to Major Tom
    John Robbins - March 2007

  • Test Run: AJAX Test Automation
    Dr. James McCaffrey - February 2007
    This month James McCaffrey presents a technique that allows you to write lightweight test automation to verify the functionality of AJAX Web applications.

  • Debug Leaky Apps: Identify And Prevent Memory Leaks In Managed Code
    James Kovacs - January 2007
    When is the .NET Garbage Collector unable to reclaim memory? The answer might surprise you. Stay tuned.

  • Test Run: String Permutations
    Dr. James McCaffrey - December 2006
    The ability to programmatically create and use string permutations is essential in software testing, as James McCaffrey explains.

  • Test Run: Using Excel For Test Data
    Dr. James McCaffrey - November 2006
    This month see how to use Excel for test automation storage, whether you’re just starting out with NET, or you’re an advanced programmer.

  • CLR Inside Out: Investigating Memory Issues
    Claudio Caldato and Maoni Stephens - November 2006
    Memory issues can manifest in a wide variety of ways. This column shows you how to collect the data you need to determine what types of mem¬ory issues you are experiencing.

  • Bugslayer: Minidumps for Specific Exceptions
    John Robbins - November 2006
    This installment of Bugslayer covers the use of ADPlus to create a minidump of your Microsoft .NET Framework 2.0 pro¬cesses on specific exceptions.

  • Test Run: Competitive Analysis Using MAGIQ.
    Dr. James McCaffrey and Nasa Koski - October 2006
    The goal of competitive analysis is to compare the overall quality of your software against similar systems. But it’s not easy. Here James McCaffrey accomplishes the goal with the help of a little MAGIQ.

  • Test Run: Randomness in Testing
    Dr. James McCaffrey - September 2006
    In this installment of Test Run, James McCaffrey discusses how you can generate random test case data.

  • Use The Source, Luke: Source Server Helps You Kill Bugs Dead In Visual Studio 2005
    John Robbins - August 2006
    The latest releases of WinDBG and Visual Studio know exactly how to use source server, so its benefits are available to both .NET and native C++ developers. See why this is so important in tracking down bugs.

  • Advanced Basics: Monitor Your Apps with System.Diagnostics
    Brad McCabe - July 2006
    It never fails. The application you just deployed ran great on your development machine—but stumbles in production. The problem might show up right away or maybe it creeps up over time. Now what?

  • Share The Load: Report Visual Studio Team System Load Test Results Via A Configurable Web Site
    Wen Ding - June 2006
    This article discusses a new load test tool in Visual Studio 2005 Team System for performance and stress testing your Web sites, Web services, and other server components. Combined with its handy reporting capabilities, the load test tool provides some powerful options for sharing and managing test results.

  • Test Run: Five Ways to Emit Test Results as XML
    Dr. James McCaffrey - June 2006
    The use of XML files in software testing has steadily increased over the past few years. Test case data, test harness configuration information, and test result data are now stored as XML. Recently I was writing some .

  • Bug Bash: Let The CLR Find Bugs For You With Managed Debugging Assistants
    Stephen Toub - May 2006
    Managed Debugging Assistants are new to the .NET Framework 2.0 and help you to discover serious bugs quickly. Learn how to harness their power.

  • Test Run: Stress Testing.
    Dr. James McCaffrey - May 2006
    Stress testing is a fundamental quality assurance activity that should be part of every significant software testing effort. The key idea behind stress testing is simple: instead of running manual or automated tests under normal conditions, you run your tests under conditions of reduced machine or system resources.

  • No More Hangs: Advanced Techniques To Avoid And Detect Deadlocks In .NET Apps
    Joe Duffy - April 2006
    You can combat deadlock using a combination of disciplined locking practices which Joe Duffy aptly explains in this article.

  • Mutant Power: Create A Simple Mutation Testing System With The .NET Framework
    James McCaffrey - April 2006
    With mutation testing, the system under test is changed to create a faulty version called a mutant. Here James McCaffrey explains how to do this in .NET.

  • .NET Profiling: Write Profilers With Ease Using High-Level Wrapper Classes
    Joachim H. Fröhlich and Reinhard Wolfinger - April 2006
    Here Joachim H. Fröhlich and Reinhard Wolfinger show you how to get all the great functionality of the .NET Profiling API the easy way, with custom wrappers.

  • Test Run: Determining .NET Assembly and Method References
    James McCaffrey - March 2006
    Before you can test any software system effectively, you must understand the system under test. If the system includes the Microsoft® . NET Framework, understanding the system under test includes understanding its assembly and method dependencies.

  • Bugslayer: Strengthening Visual Studio Unit Tests
    John Robbins - March 2006
    Visual Studio 2005 brought so many new features to the table that it can seem almost overwhelming. One of the most exciting additions is the new unit testing features found in the Test menu on the main menu bar.

  • Unit Testing Tips: Write Maintainable Unit Tests That Will Save You Time And Tears
    Roy Osherove - January 2006
    Everybody's talking about unit testing and you want to get into the game too. But you don't want the tests to take up all your development time and energy. Fortunately Roy Osherove is here to dispel some testing myths and put you on the road to efficient unit testing.

  • Test Run: Software Testing Paradoxes
    James McCaffrey - December 2005
    Paradoxes are fun. In this month's column I show you three interesting cases that can occur when you are performing software testing. They're fundamentally mathematical in nature, and they can be a useful addition to your troubleshooting arsenal.

  • .NET Matters: BigInteger, GetFiles, and More
    Stephen Toub - December 2005

  • Bugslayer: SUPERASSERT Goes .NET
    John Robbins - November 2005
    Those of you who have been reading this old Bugslayer column over the last nine years have branded into your frontal lobe a single word: ASSERT! Anytime you can have the code tell you about a problem instead of having to find it by slaving away with a debugger is a huge timesaver.

  • Test Run: Low-Level Web App UI Test Automation
    James McCaffrey - October 2005
    As Web applications have become more complex, testing them has become more important. There are many testing techniques available to you. For example, in the April 2005 issue of MSDN®Magazine, I describe a simple JScript®-based system that can test a Web app through its UI by using the Internet Explorer Document Object Model.

  • Call MOM: Instrument and Monitor Your ASP.NET Apps Using WMI and MOM 2005
    Michael Jurek - September 2005
    The current version of Windows Management Instrumentation (WMI) satisfies many current and future manageability requirements. In this article Michael Jurek demonstrates how WMI provides important system management capabilities and develops a WMI-aware monitoring solution you can use to instrument your ASP.NET applications. He then introduces the capabilities of MOM 2005 that allow you to monitor these instrumented applications.

  • Test Run: Low-Level UI Test Automation
    James McCaffrey - September 2005
    There are several ways to test a Windows®-based application through its user interface. For example, in the January 2005 issue of MSDN®Magazine (Test Run: Lightweight UI Test Automation with . NET) I described a lightweight technique for testing .

  • Winsock: Get Closer to the Wire with High-Performance Sockets in .NET
    Daryn Kiely - August 2005
    The Win32 Windows Sockets library (Winsock) provides mechanisms to improve the performance of programs that use sockets, and the Microsoft .NET Framework provides a layer over Winsock so that managed applications can communicate over sockets. To use all these layers to write a truly high-performance socket-based application requires a little background information, as Daryn Kiely explains here.

  • Easy UI Testing: Isolate Your UI Code Before It Invades Your Business Layer
    Mark Seemann - August 2005
    The User Interface Process Application Block (UIP) from the Microsoft Patterns & Practices team can help you isolate your UI, write unit tests for your UI logic, and write a UI that really is the thin layer it was always meant to be. Mark Seemann shows you how it's done in this article.

  • Test Run: Test Harness Design Patterns
    James McCaffrey and James Newkirk - August 2005
    The Microsoft® . NET Framework provides you with many ways to write software test automation. But in conversations with my colleagues I discovered that most engineers tend to use only one or two of the many fundamental test harness design patterns available to them.

  • Debugging: Root Out Elusive Production Bugs with These Effective Techniques
    Matt Adamson - July 2005
    Errors happen. But in production, error logs often provide little or no help in pinpointing the exact line of code in which the problem originates. You can't usually isolate the root cause by modifying code in a production environment because recreating the exact same environment is very difficult due to the large number of potential software and hardware configurations. This article provides some concrete steps you can take to get at the heart of the problems in your production code.

  • Bugslayer: Unhandled Exceptions and Tracing in the .NET Framework 2.0
    John Robbins - July 2005
    By now, you've certainly heard about the big changes coming in Visual Studio® 2005, but when it's time to move your code over it will be the small things that trip you up. In this column, I want to cover two of the many excellent changes that you could easily overlook as you make the move to the new runtime and development tools.

  • Know Thy Code: Simplify Data Layer Unit Testing using Enterprise Services
    Roy Osherove - June 2005
    If you want to employ unit testing and test-driven development techniques in your database application development process, you'll have different factors to consider than you do when you're not involving a database. For example, you have to maintain a consistent state within the database and be able to roll back transactions when necessary. This article shows you how to get the best of unit testing for your database apps in a safe, usable manner.

  • Extreme ASP.NET: Tools of the Trade: Application Center Test
    Rob Howard - June 2005
    When you sit down to write an ASP. NET application, how much time do you spend thinking about performance? It's unfortunate, but for most developers performance is an afterthought. Performance planning and design really need to be front and center.

  • Test Run: The Analytic Hierarchy Process
    James McCaffrey - June 2005
    Most software testing takes place at a relatively low level. Testing an application's individual methods for functional correctness is one example. However, some important testing must take place at a very high level—for example, determining if a current build is significantly better overall than a previous build.

  • Test Run: Lightweight UI Test Automation for ASP.NET Web Apps
    James McCaffrey - April 2005
    The release of ASP. NET revolutionized Web development and made it easy to create full-featured Web applications. Visual Studio® 2005 and ASP. NET 2. 0 will let you add even more functionality to your applications, but the more features a Web application has, the more important testing becomes.

  • Test Run: Automate Your ASP.NET Web Services Testing
    James McCaffrey - March 2005
    It's no exaggeration to say that Web services are revolutionizing application-to-application communication. Web services are already being used extensively in corporate intranet environments and are making their way into commercial use, too.

  • Bugslayer: Mini Dump Snapshots and the New SOS
    John Robbins - March 2005
    In debugging some large Microsoft® . NET Framework-based ap-plications over the last few months, I've been spending more time looking at mini dumps than at live processes. This is mainly because in those large applications problems surface when the apps are running in production and not on test systems.

  • Testing: Get Your Customers Involved in the Testing Process with Functional Tests in Excel
    Will Stott - February 2005
    For specification documents to be truly valuable, they need to give an accurate picture of all the requirements of a project. This article describes how the communication value of specification documents can be improved by permitting users to test the code under construction using the Framework for Integrated Test (FIT), an open-source tool. It also explains how you can build a Windows Forms application in C# (WinFITRunnerLite) that converts functional tests, as written by your customers using Excel, into a form that allows you to run them with FIT against the code you're developing.

  • CLR Profiler: No Code Can Hide from the Profiling API in the .NET Framework 2.0
    Jay Hilyard - January 2005
    The common language runtime (CLR) profiling API makes available information about the application domains, assemblies, and classes that are loaded and used in a process, just-in-time (JIT) compiler notifications, memory usage tracking, tracing of events, exception tracking, managed to unmanaged code transitions, and the state of the runtime. And if that weren't enough, you will find a nicely enhanced profiling API in the .NET Framework 2.0. Find out what's coming up in this next version.

  • Test Run: Lightweight UI Test Automation with .NET
    James McCaffrey - January 2005
    Manual user interface testing is one of the most fundamental types of software testing and it's the kind of testing that most software engineers first experience. Paradoxically, automated user interface tests are probably the most technically challenging kind of test to write.

  • .NET Code Tuning: Make Your Apps Fly with the New Enterprise Performance Tool
    John Robbins - December 2004
    Because the common language runtime (CLR) is a black box, it's pretty hard to divine what's going on when you want to track down performance problems. Microsoft will be delivering a brand new profiler, the Enterprise Performance Tool (EPT), as part of Visual Studio 2005 Team Developer Edition that's ideal for use on a production system because it offers some very lightweight means of collecting performance data. Here John Robbins takes you on a tour.

  • Test Run: API Test Automation in .NET
    James McCaffrey - November 2004
    The most fundamental type of software test automation is automated API testing. API testing essentially entails testing the individual methods that make up a software system rather than testing the overall system itself.

  • .NET Internals: Examine Running Processes Using Both Managed and Unmanaged Code
    Christophe Nasarre - October 2004
    There are plenty of times when you need to get information on running processes, not the least of which is during performance tuning. Using the techniques in this article and special .NET classes you'll see how to get a process' ID, name, priority, number of threads, kernel handle, and memory consumption, as well as its user-mode, kernel-mode, and total elapsed running time and put them to use in a custom app called AssemblyBrowser.

  • Unit Testing: Mock Objects to the Rescue! Test Your .NET Code with NMock
    Mark Seemann - October 2004
    The problem: unit testing libraries, especially data access components, that have a complex set of dependencies. The solution: providing a dynamic mock implementation of your data access classes. Here the author explains just how to make testing easier and more reliable using NMock.

  • Test Run: Automate Testing of Your Stored Procs
    James McCaffrey - September 2004
    Many Windows®-based applications have a SQL Server™ back-end component that contains stored procedures. Although techniques to automatically test functions in the front-end code are well known, the techniques to write test automation for stored procedures are not.

  • Bugslayer: Three Vital FXCop Rules
    John Robbins - September 2004
    In the June 2004 installment of the Bugslayer column, I introduced the amazing FxCop, which analyzes your . NET assemblies for errors and problems based on code that violates the . NET Design Guidelines.

  • C++ Q&A: Performance Monitoring, Managed Extensions, and Lock Toolbars
    Paul DiLascia - September 2004
    In the June 2004 issue of MSDN®Magazine, I described a class called ShowTime that you can use to do simple performance monitoring for your app. ShowTime uses its constructor/destructor to record the start/stop times of its existence so you can instantiate it in a block of code like so: { ShowTime st(_T("Total time is:")); // some lengthy operation } .

  • Virtual Server 2005: Program Customized Testing Environments Without Trashing Your Machine
    Ben Waldron - August 2004
    Efficient testing can require many different machine and server configurations but the effort needed to manage these test environments can take a toll. Microsoft Virtual Server 2005 simplifies the provisioning and management of testing environments. This article demonstrates how the extensive Virtual Server COM API can be used to create an automated application testing environment to make your testing chores a whole lot easier.

  • Test Run: Test Automation for ASP.NET Web Apps with SSL
    James McCaffrey - August 2004
    If you're encrypting user data with Secure Sockets Layer (SSL) over HTTP and you want to test your Web applications programmatically you'll find that the techniques are not widely known. In this month's column I'll show you how to set up a test SSL server and write test automation that verifies the functionality of a simple but representative Web application.

  • .NET Matters: Debugger Visualizations, Garbage Collection
    Stephen Toub - August 2004

  • Test Run: Using Combinations to Improve Your Software Test Case Generation
    James McCaffrey - July 2004

  • Bugslayer: Bad Code? FxCop to the Rescue
    John Robbins - June 2004

  • C++ Q&A: Performance Optimization, Controls versus Components
    Paul DiLascia - June 2004

  • Debugging: DataTips, Visualizers and Viewers Make Debugging .NET Code a Breeze
    Morgan Skinner - May 2004
    There is a whole host of new goodies in upcoming release of Visual Studio 2005 that will enhance your debugging experience. One such improvement will make it easy to visualize types within the debugger. This article discusses those improvements and covers debugger attributes and type visualizers. In addition, the author shows you how to extend the display of your own types with custom attributes and how to plug in an assembly to visualize.NET types built into the framework.

  • Testing: Perform Code Coverage Analysis with .NET to Ensure Thorough Application Testing
    James McCaffrey - April 2004
    When running your tests how do you know which parts of your product code are actually executed and tested? This article presents a complete system called Fundamental Function code coverage that operates at the method level. The author gives an overview of the system so you can understand code coverage principles, explains the key parts of the underlying code, and discusses how code coverage fits into the overall product development cycle. After reading this article you will be able to perform code coverage analysis on any .NET software system.

  • Test-Driven C#: Improve the Design and Flexibility of Your Project with Extreme Programming Techniques
    Will Stott and James Newkirk - April 2004
    Test-driven development (TDD) should be on every developer's radar screen because a comprehensive set of tests makes for maintainable code and frees you from having to create a perfect design up-front. This article explains how to perform TDD and takes you step-by-step through a number examples to get you started.

  • Instrumentation: Powerful Instrumentation Options in .NET Let You Build Manageable Apps with Confidence
    Jon Fancey - April 2004
    As systems grow and become more heterogeneous, so their complexity increases. The more code you write, the more that can go wrong. The more that can go wrong, the more you need a good instrumentation policy. In this article, the author looks at the various technologies available in the .NET Framework, such as tracing, logging, WMI, EIF, which are designed to help you. He will also look at the pitfalls you should avoid and provide you with the fundamentals from both a technical and managerial perspective so that you can instrument your code effectively.

  • Stress Testing: Custom LoadGenerator Tool Identifies the Issues Your Application Faces Under Stress
    Brian Otto - April 2004
    It's easy to postpone stress testing when developing an application, and it's easy to forgo it altogether. Having an easy-to-use framework at your fingertips to conduct these tests can make the task far less painful. This article walks you through an application that eases the task of generating load for a variety of layers within an application.

  • Editor's Note: Testing, Testing 1 2 3
    Joshua Trupin - April 2004
    Each month dozens of readers turn to this page for the latest news on what the editors of MSDN Magazine are thinking. And we do our best to oblige with our hard-hitting yet pithy observations on the state of the world around us, the latest in XML fashions, what's coming up in the current issue, and more.

  • .NET Internals: Rewrite MSIL Code on the Fly with the .NET Framework Profiling API
    Aleksandr Mikunov - September 2003
    In this article, the author shows how to dynamically rewrite Microsoft Intermediate Language code on the fly using the Profiling API of the CLR. Unlike approaches based on Reflection.Emit, this scheme works with the existing assemblies and doesn't require the creation of proxy or dynamic assemblies. The need for IL code rewriting emerges when you want to make your changes transparent to the client and preserve the identity of classes. This technique can be used for creation of interceptors, pre- and post-processing method calls, and code instrumentation and verification.

  • Windows Server 2003: Discover Improved System Info, New Kernel, Debugging, Security, and UI APIs
    Matt Pietrek - June 2003
    There's a lot to say about Windows Server 2003. First of all, it's the first operating system with built-in .NET Framework support, and it's the first 64-bit OS from Microsoft. But wait, there's more! There are lots of new features and APIs in this version as well. For instance, Windows Server 2003 features Hot Add Memory and a number of other arcane new tidbits. There are new APIs for handling threads, directories, and files, and new features like the low fragmentation heap for managing memory and system information. There's vectored exception handling and new UI APIs as well.OS internals expert Matt Pietrek takes a look at the additions he finds most interesting and useful so you'll have a good place to start when you dive into Windows Server 2003.

  • Bugslayer: SOS: It's Not Just an ABBA Song Anymore
    John Robbins - June 2003
    Hidden deep inside the Microsoft .NET Framework 1.1 you'll find Son of Strike (SOS). If your app is a pure managed code, your development and debugging tasks are easily handled by existing Microsoft tools. If you're on border between managed and native code SOS is your man.

  • Debugging Tool: Build a Logging and Event Viewing Library to Help Debug Your .NET Framework-based App
    Daryn Kiely - May 2003
    Building a basic, reusable application framework can make development quicker and easier. This allows you to focus more on the problems at hand and less on the repetitive tasks involved in building any application. In this article, the author presents a framework that provides facilities to access the registry and an extensible framework for logging messages to a console window or the Event Viewer. This reusable framework can be included as a library in your projects, allowing you to display an enhanced, color-coded message log and dynamically change logging levels.

  • Design: Inspect and Optimize Your Program's Memory Usage with the .NET Profiler API
    Jay Hilyard - January 2003
    Developers using .NET often make memory leak tracking a low priority because the common language runtime takes care of garbage collection. What few developers realize, however, is that their objects' lifespans, along with their size and what other objects have been instantiated, all affect how they are cleaned up. Depending on the particular circumstances, these combinations can negatively affect performance, especially over the lifetime of an application. This article presents a way for developers to see memory usage and understand garbage collection using the .NET Profiler API. Along the way, a sample application to demonstrate these principles is built.

  • Debug: Detect and Plug GDI Leaks in Your Code with Two Powerful Tools for Windows XP
    Christophe Nasarre - January 2003
    In a previous article, the author devised a simple method to detect Graphical Device Interface (GDI) objects that are not properly released by Win32-based applications on Windows 9x platforms. Because some newer versions of Windows require a slightly different approach to GDI leaks, the author has updated his techniques for those operating systems. He builds and explains two tools designed to detect and eradicate GDI leaks in applications running on Windows XP, Windows 2000, and Windows NT.

  • Scale: Real-World Load Testing Tips to Avoid Bottlenecks When Your Web App Goes Live
    Jeff Dunmall and Keith Clarke - January 2003
    Load testing should be part and parcel of every Web development effort, and it should be performed early in the process. However, if you think you can load test using your development environment, you're going to have some surprises when you go live. In this article, the authors outline the process of planning your load testing effort, considering which machines to use, how many users to simulate, which tools are right for you, and how to interpret your results.

  • Test: Build Quick and Easy UI Test Automation Suites with Visual Studio .NET
    James McCaffrey - January 2003
    The .NET Framework provides a surprising new way to quickly and easily create user interface test automation. By using objects in the System.Reflection and System.Threading namespaces, you can write automated tests in minutes instead of hours. This article walks you through the building of a typical Windows-based application that will be used as the test subject. The author then runs through the creation of a C#-based test tool that simulates clicking the test app's UI controls and checks the application's state. After the tool is built, the author explains in detail how it works so you can modify and extend it for your own use.

  • Editor's Note: Elevating Test and Debug
    - January 2003
    Programming is fun. It's one of the world's great jobs, pure mental exercise with a golden payoff at the end. There's nothing like the feeling of accomplishment when that program you wrote is working, looks good, and is ready to ship.

  • Advanced Basics: Advanced Features in Visual Basic .NET and Testing for Scalability
    Ken Spencer - December 2002

  • The XML Files: WS-Security, WebMethods, Generating ASP.NET Web Service Classes
    Aaron Skonnard - September 2002

  • Advanced Basics: Reducing Memory Footprints, Gathering Process Info with MSDNMagProcessMonitor
    Ken Spencer - September 2002

  • Windows XP: Escape from DLL Hell with Custom Debugging and Instrumentation Tools and Utilities, Part 2
    Christophe Nasarre - August 2002
    Building on his article published in the June issue, which demonstrated several ways to get process and DLL-related information from APIs such as PSAPI, NTDLL, and TOOLHELP32, the author presents some unusual ways to get system-oriented info that you can easily integrate in your own toolkit. There are three tools included as samples: LoadLibrarySpy, which monitors an application and detects which DLLs are really loaded; WindowDump, which retrieves the content and a detailed description of any window; and FileUsage, which redirects console-mode applications to tell you which process is using any opened file.

  • Bug Tracker: Build a Configurable Web-Based Bug Management Tool Using ADO.NET, XML, and XSLT
    Roy Margolis - July 2002
    One of the most significant features of ADO.NET is its integration with XML. Developers can either use an ADO-like API to access the data or work directly with an XML representation of the data. This article demonstrates how both of these techniques can be used together to create Web applications that take advantage of XML standards such as XSLT. The example presented here is a bug tracking application built using C# and the.NET Framework. The development of the application covers several topics including data access using ADO.NET, the presentation of data using XSLT stylesheets, and the integration of ADO.NET with the .NET XML Framework.

  • Advanced Basics: Viewing the Values of a DataSet in a Debug Window
    Ken Spencer - July 2002

  • Windows XP: Escape from DLL Hell with Custom Debugging and Instrumentation Tools and Utilities
    Christophe Nasarre - June 2002
    DLL conflict problems can be tough to solve, but a large number of tools are available to help. There are also many Windows APIs that you can use to build custom debugging tools. Three such tools are discussed here and provided as samples. DllSpy lists all the DLLs loaded in the system and the processes that are using them. ProcessSpy enumerates the running processes and exposes the DLLs they are using, and ProcessXP displays the list of concurrent running sessions for Windows XP.

  • Editor's Note: Scratching Out Web Bugs
    - June 2002

  • Bugslayer: Symbols and Crash Dumps
    John Robbins - June 2002

  • Advanced Basics: Visual Studio .NET, Debugging .NET Applications, and More
    Ken Spencer - April 2002

  • Under the Hood: Improved Error Reporting with DBGHELP 5.1 APIs
    Matt Pietrek - March 2002

  • Bugslayer: Tester Utility, Take 3: Adding Mouse Recording and Playback
    John Robbins - March 2002

  • DHTML and .NET: Host Secure, Lightweight Client-Side Controls in Microsoft Internet Explorer
    Jay Allen - January 2002
    In the past, Web developers often used ActiveX controls if they wanted customized client-side functionality incorporated into their Web applications. Now, they can build objects supported by the Microsoft .NET Framework which are more compact, lightweight, secure, and seamlessly integrated. By hosting .NET Windows Forms controls in Internet Explorer, developers can realize many of their client-side Web development goals. This article adapts ActiveX concepts for use with Windows Forms, and builds a multifile upload application that demonstrates these techniques.

  • Bugslayer: Extending the Visual Studio .NET IDE
    John Robbins - January 2002

  • .NET CLR Profiling Services: Track Your Managed Components to Boost Application Performance
    Anastasios Kasiolas - November 2001
    The Microsoft .NET platform provides you with a rich set of services for building profilers and application monitors for applications targeting the Common Language Runtime (CLR). These services expose runtime events that occur during the execution of a .NET application. They can be used to obtain information about managed code being executed under the runtime. This article describes the .NET CLR Profiling Services and shows how to use the services to build a simple profiler that will provide hot spot information for any .NET application. The sample profiler can easily be modified to suit other profiling and monitoring needs.

  • Under the Hood: TypeRefViewer Utility Shows TypeRefs and MemberRefs in One Convenient GUI
    Matt Pietrek - November 2001

  • Bugslayer: Handling Assertions in ASP.NET Web Apps
    John Robbins - October 2001

  • Bugslayer: Optimize and Trim Your Code with New Switches in Visual C++ .NET
    John Robbins - August 2001

  • .NET Mobile Web SDK: Build and Test Wireless Web Applications for Phones and PDAs
    Eric Griffin - June 2001
    Cell phones, PDAs, and other wireless devices that connect with the Internet enjoy growing popularity, making wireless applications more important and especially useful to companies with remote employees. This article presents an overview of the .NET Mobile Web SDK for building wireless apps. The technologies and design decisions that influence the development of mobile Web applications are discussed along with specific strategies for setting up a development environment using an emulator and building a real-world mobile Web application.

  • Bugslayer: ILDASM is Your New Best Friend
    John Robbins - May 2001

  • Bugslayer: Assertions and Tracing in .NET
    John Robbins - February 2001

  • Active Scripting APIs: Add Powerful Custom Debugging to Your Script-Hosting App
    Mike Pellegrino - December 2000
    Active Scripting is a powerful tool for adding advanced features such as macro capabilities to custom applications. This creates a need for integrated debugging services for new features added with scripting. To address this need, Microsoft has provided a set of COM interfaces for developing debugging services from within the Active Scripting framework. This article illustrates how to use the debugging services published within the Active Scripting framework to create a full-featured script debugger that can provide a multitude of debugging actions including setting breakpoints, call stack viewing, variable browsing, immediate-window viewing, thread enumeration, and application enumeration.

  • Bugslayer: Improving Runtime Performance with the Smooth Working Set Tool-Part 2
    John Robbins - December 2000

  • Bugslayer: Improving Runtime Performance with the Smooth Working Set Tool
    John Robbins - October 2000

  • Under the Hood: A Tale of Real-world Debugging
    Matt Pietrek - September 2000

  • Bugslayer: A COM Symbol Engine Aids Debugging
    John Robbins - August 2000

  • A Simple XML-driven Tool: Monitor Your Web Site's Activity with COM and Active Scripting
    Panos Kougiouris - July 2000
    This article describes a simple Web site monitoring tool built with XML, JScript, Windows Script Host, and COM objects. Although it is not intended to replace complete Web site monitoring software products, it has many useful features that help to keep Web servers up and running. An XML configuration file specifies which Web sites to monitor and the actions to be taken if the site isn't functioning properly. In addition, the tool can be scheduled to run at any specified interval using the Windows Task Scheduler. Functions that probe the sites, log events, and send e-mail notifications are written in JScript.

  • Bugslayer: Tester, Take Two-TESTREC.EXE Updates Previous Version of the Tester Utility
    John Robbins - June 2000

  • Bugslayer: Windows 2000 and LDR Messages, A COM Symbol Engine, Finding Bloated Functions, and More
    John Robbins - April 2000