NCover Documentation
Docs  ›  Extras  ›  Glossary


Application Domain - in .NET programming, a space for individual apps that are running so they don't interfere with one another.

Artifact - Any file that comes out of the build process. These files typically include executables, log files, DLL assemblies, PDB files, etc.

ASP.NET - a code library for developing web-based .NET apps that run on the IIS server. See Microsoft's ASP home page for more details.

Assembly - In .NET, this is a file with either a .exe or .dll extension. The first is an executable file most commonly thought of as an application. The second is a library of code that can be used in an execution. In either case, the code in the file is compiled into the CLR. Read more about .NET assemblies here.

Assembly Language - one layer above machine code is the basic language representing processing steps used by the machine CPU. In .NET programming, the CLR language is converted to assembly code "just-in-time" for it to be processed by the chip.

Application Programming Interface (API) - a set of instructions in one program that lets it interact with other programs that want to use the functionality it provides. Exp: Program A has an API. Program B wants to use Program A. Program B will reference the set of instructions provided by Program A in order to access its functionality. By abstracting specific functionality to a few method calls, Program A can reliably and safely be used.

Bitness - refers to the bit depth of a program. Example: 32- or 64-bit Windows 7.

Branch Point - These are the traffic intersections of computation where execution can take different routes. Example: "if-else" statements. Branch points are identified in the CLR and NCover counts these points to create a percentage for a given section of code.

Build - the process used to compile code into machine language. In .NET, this user-initiated process turns the code into an intermediate language called the Common Language Runtime (CLR). Once the program is run, Microsoft compiles the CLR into the appropriate byte code for the machine in service.

Build Server - software that automates the build process. Several servers are common in .NET development, including MSBuild and NAnt. Build servers usually operate with configuration files written in XML that describe tasks the user wants to accomplish.

Common Intermediate Language (CIL) - the lowest-level human-readable programming language defined by the Common Language Infrastructure (CLI) specification and used by the .NET Framework and Mono.

Class - a concept of object-oriented code in which a data structure can house other variables, methods, and etc. In doing so, it classifies, or logically isolates, those variables and methods from others in a program.

Code Base - the entire library of an application. The code base can be in any number of formats, including OO code and Assembly code.

Command Line - the Kernel interface in most operating systems. In Windows OS, this is a program called "Command Prompt," which allows for manual calls into the Kernel. MACs have this as the "Terminal". Beginners should use caution when typing commands in the prompt.

Common Language Runtime (CLR) - The .NET intermediary language that is compiled "just in time" to assembly code when a program is finally executed. Visit Microsoft's documentation for more about the CLR.

Continuous Integration (CI) - the consolidation of build, test, and report processes to facilitate agile development and organizational awareness.

Continuous Integration Server - one of several available .NET servers that provide continuous integration services, including TeamCity and CC.NET.

Cover - the process through which code is instrumented and profiled during its execution in order to produce coverage data. This process will be different depending on the development team and tools used. Coverage with NCover makes use of PDBs and the CLR to keep a count of symbols and branches. The larger development process that NCover is a part of can also vary. Covering code is best done with reference to a team's unique development work processes.

Coverage - In its broadest sense, code coverage is a number that indicates the amount of code executed, e.g., by a test. 0% coverage indicates no code was exercised. 100% coverage indicates all code was exercised in a given code base. There are several standard coverage metrics used today, each with a mathematical definition. NCover calls the process of acquiring this data profiling. NCover takes in code, usually with automated tests, and spits it out again as coverage data. We call that process profiling whereby NCover injects its code on top of another application. Like a digital sensor, it tracks entrances and exits from application code by tests. The cumulative data is rolled up and averaged, providing coverage percentages. Because most developers have prior knowledge of the code, coverage is usually a transparent process that provides greater clarity to the developer. For greater depth on the types of coverage available / in use in computing science, see

Cruise Control - open-source continuous integration server used in .NET development. See the CC.NET website for more details, downloads, and documentation. If you're an NCover 3 user, you can find a tutorial on how to set up CC.NET with NCover on our website.

Cyclomatic Complexity - A count of the number of linearly independent paths through a code section. Unique paths to get from start to final return in your code. Based on branch points. CC can be reported on any code block, even if statements and methods. Every piece of code has a cyclomatic complexity of 1 since there are at least that many paths through the code. "Switch" and "if" statements will increase the cyclomatic complexity of any code base. While CC is not necessarily a negative feature of code, it can lead to higher maintenance costs and grater potential for undiscovered bugs. See an expanded discussion of this topic on Wikipedia.

Decision Tree - a diagram of the conditional nature of code. Any code base can be thought of as a set of paths and branches, representing the multiple routes through code when conditional evaluations exist. While every condition is only ever 0 or 1, the placement of that conditional can make it either a major or minor branch. See the Wikipedia article for more details and examples.

Dynamic-Link Library (DLL) - Microsoft file format, which can contain code, data, and other resources. These are typically method libraries used in shared-memory. These files are necessary to run your application as well as for collecting code coverage with NCover. For more information, see Microsoft's full description. Exclude - using a regular expression, users can specify assemblies, modules, classes, methods, and properties that should not be included in coverage data. This feature is useful for eliminating negative impacts on figures due to extraneous code, such as compiler-generated code, secondary methods, or anything else that is deemed to be unnecessary.

Executable - a file containing a set of instructions that the computer carries out. In Windows environments, users will generally recognize these by the familiar .exe extension. Executables are artifacts of the build process and are typically outputted to a ..\bin\Debug\ or ..\bin\Release directory when building from a VisualStudio Solution.

Execution - an process during which a computer runs the instructions (code) that are issued to the processor.

Execution Graph - the internal representation of the program instruction logic that describes states of execution and the transitions between states. A "graph" should not be confused with a visual "chart". It is a directed graph representing logic and flow, not a visual aid NCover uses to describe code complexity. This is similar to a Call Graph. But whereas a call graph is concerned with the relationship between subroutines, an execution graph is a directed graph at the assembly level. A call graph could be shown in pseudocode: writerecord -> writefields -> writefied. An execution graph is assembly code: push ax, 1 -> pop ax -> jump 0xF332.

Extensible Application Markup Language (XAML) - a declarative XML syntax for .NET programming in which program routines are translated into XML format. XAML is the language for the TFS build framework in VS2010. Read about XAML from Microsoft.

Extensible Markup Language (XML) - a tag-based syntax for structuring data content, also in the same family of languages as HTML. XML is used primarily as an intermediary data format (in transfers and storage) in just about every type of application, web-based or console.

Final Builder - an automated build solution software with a GUI interface. See the FinalBuilder website for more details.

Flag - NCover's command-line arguments of the form " //[arg] ". Example: //x C:\Users\Support\Desktop\coverage.nccov to produce a coverage file.

Framework - a set of "helper" code libraries that can be used again and again for development purposes. Typically they contain classes and methods common to most all programs, which are needed to build larger applications.

Functional Test - a type of "black-box" test in which the tester usually has no previous knowledge of the code base. A set of tests is coded, which feed expected data to the program in order to verify its defined operation.

Gallio (MBUnit) - an open-source test-automation platform, including testing framework MBUnit for .NET. Gallio "provides a common object model, run-time services and tools (such as test runners) that may be leveraged by any number of test frameworks ." See the Gallio website for more details.

Graphical User Interface (GUI) - a display (e.g., a window) that aids in the interaction with software. Nearly all applications have a GUI, including the one you're seeing now.

Hyper Text Transfer Protocol (HTTP) - the language of the Web, HTTP is a scripting language for structuring documents that Web browsers can read. NCover 4's interface is based on HTTP.

Identity (ID) - The specific number associated with a process that is executed. All processes are assigned a unique number by the CLR. Because an ID is assigned by a machine, each machine can assign a different ID to the same process.

Include - using a regular expression, users can specify the exact (or general namespace) assemblies, modules, classes, methods, and properties that covered. This feature is useful when focusing on a specific section of code to profile. Users can save time by quickly excluding from coverage all but the identified code components.

Instrument - the process by which NCover injects itself into the profiled application's code. Most all code coverage must run "on top of" an application in order to collect information about what code is/is not called. NCover's instrumentation generally increases the average application's run time by about 1.5 times its usual clock speed.

*Integration Test *- modules in a code base are combined and tested to ensure they will run together.

Internet Information Server (IIS) - Microsoft's server for running .NET web apps. See the IIS website for greater detail.

Intermediate Language (IL) - is the language of an operating system designed to aid in the analysis of a program.

JavaScript (JS) - a web scripting language, mainly used for manipulating HTML and handling web display.

JavaScript Object Notation (JSON) - a javascript-like syntax to represent data structures such as associative arrays and objects. It is mostly used to serialize and transmit data between servers and web applications (as alternative to XML). Files written in JSON notation end in a .json. For more information, the Wikipedia article is a good start.

Kernel - a computer's interface between its applications and the hardware (processor, memory, and other components). The Kernel is responsible for taking commands from applications and passing them to the hardware. Accessing the Kernel is as simple as opening a command line.

Log File - any file containing data about an execution. NCover, MSBuild, TeamCity, and more generate log files are part of their execution. These files will typically contain data about events and statuses (which assemblies were built, called, and covered) during program operation. NCover's log file can be particularly important when investigating issues related to improper coverage.

Machine Code - The set of instructions directly understood by the processor chip on a given system. Given the multiplicity of chips, there are any number of machine codes. In .NET these are abstracted away when programmers use a language like C#. Eventually, though, every program is converted to machine code when executed.

Managed Code - the term Microsoft gives to code that only runs in a CLR. This is typically .NET Framework code.

Manual Testing - a type of black-box testing in which a human tester (with no previous knowledge of the code base) uses an application in either a random or controlled execution to assess the quality of the software. Manual testing typically involves clicking buttons, switching window panes, or in some way exercising the code as deemed necessary by the user.

Merge - NCover can consolidate multiple coverage runs on the same code into one coverage file, providing users an aggregate. In the process, NCover will recalculate all coverage values from the raw XML files (as opposed to just averaging percentages) and then re-average the coverage.

Method - A "function" is synonymous with a method.

Metric(s) - any of the four statistical measurements that NCover provides about .NET program code: Symbol, Branch, Method, Cyclomatic Complexity.

Microsoft Build (MSBuild) - Microsoft's answer to an integrated build solution. This program combines straight-forward scheduling with a compiler to build .NET code. MSBuild also happens to be Microsoft's Team Foundation Server build agent, albeit re-branded as TeamBuild. See the MSBuild website for more details.

Module - a file containing a collection of methods and constants. Modules can be profiled with NCover using testing frameworks such as NUnit.

Module, View, Controller (MVC) - a software design pattern that separates an application into three distinct components so each may be developed and tested independently of the others. See the Wikipedia article for an in-depth treatment of the subject.

Module View, View-Model (MVVM) - a software design pattern based on MVC that aims to remove the need for UI engineers to program in native code. The Module (program logic and data) is separated from the View (UI) by providing access to WPF / Silverlight code functionality through XAML bindings. In doing so, UI engineers can focus on interaction and rely on developers for code management.

Moles - a Microsoft unit testing framework designed to isolate...

Namespace - A programming construct that logically categorizes code. Namespaces provide a unique name domain so that different classes and methods sharing the same names can be distinguished by the compiler.

NAnt - an automated build agent for .NET developers. See the NAnt website for more information and documentation.

Native code - Synonymous with Machine Code, this is the set of instructions processed by the computer's CPU.

NUnit - a .NET test framework used to create automated unit tests for .NET code. See the NUnit website for more details and documentation.

Operating System (OS) - the overarching program that controls basic operation of a machine and its applications. .NET developers are typically working on one or more distributions of Microsoft.

Plugin - An application that resides within a larger one in order to add functionality to the latter's operation. For example, the NCover plugin for Visual Studio.

Process Explorer - a Microsoft development tool that allows users to view all processes running on a machine. It provides data such as environment variables, memory allocations, etc. This free tool is available on the download page.

Profile - the computational process of acquiring coverage data. For .NET development, this generally consists of reading the CLR to calculate branch points and symbol points.

Program Database (PDB) - a Microsoft file format with the extension .pdb. These files are created when code is compiled and contain "a list of all symbols in a module with their addresses and possibly the name of the file and the line on which the symbol was declared." NCover requires PDBs in order to gather coverage data. Find an in-depth description of PDBs from Microsoft.

Project - a collection of settings and data associated with a profiled application. Every project has settings specified during setup that instruct NCover when and how to collect coverage. The coverage data itself is linked within a database to a unique project name.

Project File - an XML file containing the settings for a coverage project. This file is generated using the export command on the project configuration GUI. Once a file is generated, it can be stored / exported for future use.

Property - a data structure that (in C# and other Object-Oriented languages) encapsulates variables by providing read / write access to them, typically through get / set methods. For more details and examples, see the Wikipedia article.

Quality Assurance (QA) - in software development, the art and practice of instituting, maintaining, and furthering software integrity. Quality can be evaluated in both quantitative and qualitative measurements.

Quick Test Pro (QTP) - a Hewlett Packard software and framework for automating functional and regression testing. See the QTP website for more details.

Reflector - a free .NET tool from RedGate that translates compiled assemblies into human-readable code for inspection. Reflector can be particularly helpful when identifying extra compiler-generated code, introduced as a function of the CLR's code optimization process.

Regular Expression (REGEX) - a language-independent syntax for referencing character strings, typically for searches. For a general introduction, see Wikipedia's REGEX article. To check your REGEX, open a REGEX checker.

Regression Test - software testing aimed at finding errors in code after changes are made to an existing application. Read a more detailed explanation on Wikipedia.

Report - refers to the output XML coverage file generated by NCover as well as the coverage data displayed in NCover Explorer.

Runtime - the time during which a computer carries out a program. Synonymous with execution.

Satisfactory - the state in which desired coverage levels intersect with actual coverage achieved. NCover allows users to specify satisfactory coverage thresholds as a mechanism for incrementally raising coverage and meeting desired goals.

Selenium - a program that automates web application testing and is used in .NET ASP development. See the Selenium website for more details.

Sequence Point - in imperative code, a point in which all previous implications have been realized and no future implications have yet been realized. For .NET developers using VisualStudio, this is simply any place that the debugger stops when debugging code.

Serialize - to convert a data object into a format that permits storage and transmission, which may later be reverted to the original format. See the Wikipedia article for an advanced discussion.

Server - a program that runs as a service which is responsible for receiving input from other programs and executing instructions. MSBuild is an example of a build server. The server is distinct from the machine it is running on. Typically, development teams have a dedicated machine that runs a server.

Service - a program that runs in the background (i.e., without a GUI) because it does not require user input. Some examples are IIS, ITunes updater, and TeamCity Agent.

Silverlight - the Microsoft Web framework (and counterpart to Adobe Flex) for interactive application development. Silverlight can be downloaded from the Silverlight website.

Solution - the Visual Studio file (.sln extension) that houses all of a program's source code and related content. See the Microsoft explanation for details.

Source file - a document containing .NET programming, such as C# with a .cs extension.

Source Lines of Code (SLOC) - a measure of program size by its lines of code.

Static - a feature of object-oriented code in which a class and its members can be shared, but which will not change. Static classes and members are often used for accessing routines which do not need to create new variables / change existing values during execution. See the Microsoft C# reference for more details on this feature.

Symbol - also known as a "sequence point", it is the basic unit in most code coverage algorithms. It represents every point at which the Visual Studio debugger will stop. If you were building a Lego castle, symbols would be the individual blocks.

Team Foundation Server (TFS) - the Microsoft server solution for modern software development teams that combines source repository, build agent, and other functionality. Learn more from the TFS website.

Test Framework - a library of common code snippets used to write tests. Developers will utilize these one-size-fits-all components to craft tests unique to their code. The most common in .NET are NUnit and MSTest.

Test Complete - automated testing tool and GUI that allows for the creation and execution of tests. See the TestComplete website for more details and to download.

Testing - The practice of exercising your code, manually or automatically, to ensure proper execution. For a good article on recommended test-driven development, see Code coverage is a key component to test validation and quality assurance.

Threshold - a percentage of coverage desired by an NCover user, which is implemented in NCover as a way to track the satisfactory / unsatisfactory as well as minimum level of coverage achieved.

Typemock - a software company specializing in developing unit testing tools, the most popular of which is Isolator in .NET development. Isolator, like Moles, allows for unit test development independent of the operating system, supplying pre-configured values to a unit test instead of retrieving system-specific values from the OS.

Uncovered - a state in which one or more tests did not execute application code. In such cases, NCover reports the code with a red highlight in the source code viewer.

Unit test - an automated test in which individual sections of code are examined to assess their proper operation.

Unsatisfactory - in NCover, a state in which a user's desired coverage does not intersect with the actual coverage numbers. NCover allows users to specify satisfactory coverage "thresholds" in order to incrementally raise coverage and meet desired goals.

User account - the login type and associated privileges when using Microsoft Windows. The two most common types of user accounts are LocalSystem and Administrator. NCover is required to run with administrative privileges in order to perform its operations.

User Interface (UI) - a graphical display that lets a software end consumer interact with software logic (code).

Virtual Machine (VM) - an operating system that runs within an emulator program, allowing the operating system to run on a non-native system, and/or running two or more operating systems simultaneously.

Visual Studio (VS) - the most widely used .NET IDE, developed by Microsoft. Learn more from the VS website.

Windows Communication Foundation (WFS) - Microsoft's .NET API for service-oriented applications. See the Microsoft website for details. Windows Forms (WF) - the API for Microsoft's .NET framework. See the Microsoft website for details.

Windows Presentation Foundation (WPF) - a Microsoft code architecture that "provides developers with a unified programming model for building rich Windows smart client user experiences that incorporate UI, media, and documents." See the Microsoft website for details.

Windows Workflow Foundation (WWF) - a Microsoft code architecture that "provides a programming model, in-process workflow engine and rehostable designer to implement long-running processes as workflows within .NET applications." See the Microsoft website for details.

If you still need technical assistance, we can help:

Submit A Support Ticket