- Overview
- Guides
- Concepts
- Considerations And Constraints
- Absolute File References
- Assembly Colocation Assumptions
- Concurrent Use Of Test Resources
- Cross Application Domain Testing
- Heavily Executed Code Under Test
- Implicit File Dependencies
- Multi Threaded Tests
- Netstandard Test Projects
- Project Atomicity
- Project Build Platform And Configuration
- Rdi Data Point Location
- Test Atomicity
- Unique Test Names
- Using NCrunch With Source Control
- Reference
- Global Configuration
- Overview
- Auto Adjust Clashing Marker Colours
- Build Log Verbosity
- Build Process Memory Limit
- Capabilities Of This Computer
- Coverage Marker Style
- Cpu Cores Assigned To NCrunch Or Ide
- Custom Environment Variables
- Disable Global Hotkey
- Engine Hosting Strategy
- Fast Lane Threads
- Fast Lane Threshold
- Grid Maximum Reconnection Attempts
- Grid Reconnection Delay
- Impact Detection Mode
- Listening Port
- Log To Output Window
- Logging Verbosity
- Marker Colours
- Max Failing Test Trace Log Size
- Max Number Of Processing Threads
- Max Passing Test Trace Log Size
- Max Test Runners To Pool
- NCrunch Tool Window Colors
- Node Id (Name)
- Password
- Performance Aggregation Type
- Performance Display Sensitivity
- Pipeline Optimisation Priority
- Rdi Storage Settings
- Sliding Build Delay
- Snapshot Storage Directory
- Solution Storage Data Limit
- Spinner Colours
- Terminate Test Runners On Complete
- Test Process Memory Limit
- Tests To Execute On This Machine
- Text Output Font
- Workspace Base Path
- Solution Configuration
- Overview
- Additional Files For Grid Processing
- Additional Files To Include
- Allow Parallel Test Execution
- Allow Tests In Parallel With Themselves
- Infer Project References Using Assembly
- Instrumentation Mode
- NCrunch Cache Storage Path
- Only Consider Tests Outofdate If Impacted
- Project Config File Storage Path
- Show Coverage For Tests
- Show Metrics For Tests
- Tests To Execute Automatically
- Project Configuration
- Overview
- Additional Files To Include
- Allow Dynamic Code Contract Checks
- Allow Static Code Contract Checks
- Analyse Line Execution Times
- Autodetect Nuget Build Dependencies
- Build Priority
- Build Process Cpu Architecture
- Build Sdk
- Collect Control Flow During Execution
- Consider Inconclusive Tests As Passing
- Copied Project Dependencies
- Copy Referenced Assemblies To Workspace
- Custom Build Properties
- Data Storage File Size
- Default Test Timeout
- Detect Stack Overflow
- Enable Rdi
- Files Excluded From Auto Build
- Framework Utilisation Types
- Ignore This Component Completely
- Implicit Project Dependencies
- Include Static References In Workspace
- Instrument Output Assembly
- Method Data Limit
- Ms Test Thread Apartment State
- Preload Assembly References
- Prevent Signing Of Assembly
- Proxy Process File Path
- Rdi Cache Size
- Required Capabilities
- Restrict Tostring Usage
- Run Pre Or Post Build Events
- String Length Limit
- Track File Dependencies
- Use Build Configuration
- Use Build Platform
- Use Cpu Architecture
- Runtime Framework
- Overview
- Atomic Attribute
- Category Attribute
- Collect Control Flow Attribute
- Distribute By Capabilities
- Duplicate By Dimensions
- Enable Rdi Attribute
- Environment Class
- Exclusively Uses Attribute
- Inclusively Uses Attribute
- Isolated Attribute
- Method Data Limit Attribute
- Requires Capability Attribute
- Restrict Tostring Attribute
- Serial Attribute
- String Length Limit Attribute
- Timeout Attribute
- Uses Threads Attribute
- Global Configuration
- Troubleshooting
- Tools
- Keyboard Shortcuts
- Manual Installation Instructions
Processing Queue
The processing queue window can be accessed at any time by opening the top menu and selecting Processing Queue.
Its primary function is to give you insight into work being performed by the NCrunch engine, and as such it's a great way to check up on the engine to see how well it's dealing with your solution and how much work is still left to do.
The engine itself is capable of performing three basic tasks:
Build Assembly
This involves using MSBuild to build and compile the target assembly from a standard .proj file. Build behaviour should be almost identical to the builds handled by your IDE. In cases where differences in NCrunch's build environment cause problems, have a look at troubleshooting build issues.
Build tasks will usually take priority over Test tasks, as assemblies need to be built before the tests can be run. NCrunch will attempt to perform builds in parallel where configured to do so, and will handle them in a standard order of dependency.
Build failures will be shown in the processing queue with a red X icon.
When a build is being performed for the first time, NCrunch will take a bit longer to first create a workspace for the target project. This involves copying files to a sandbox location on the hard drive so that the build does not interfere with other processes (such as the IDE). After several workspaces have been created, the build times should drop drastically.
Builds also include instrumentation work that is used by Test tasks to trace test code coverage.
Analyse Assembly
This involves loading the assembly into an application domain and using runtime reflection to analyse it, identifying tests to be run. This step only exists if you are making use of a framework that is set to use dynamic analysis. If you have tests that are incorrectly structured or contain functional problems that can be identified before they are run, you may see errors appear from this task.
Run Tests
After a build and/or analysis has been completed, NCrunch will automatically seek out and pipeline tests into tasks for execution. Tests are grouped and prioritised by considering a range of attributes and metrics. The grouping of multiple tests per 'test run' greatly reduces system load at the expense of making it sometimes harder to identify precisely which test is executing at a given moment (i.e. a task that runs 200 tests will give no specific details on the running progress of each test).
Test tasks will always be run in parallel where configured to do so, though two tests will never run concurrently within the same process.
You can see which tests are running within a particular task by drilling down onto it within the view. You can also do this to evaluate the status of the tests (i.e. pass or fail), though for daily use the tests window is much more suitable for this.
Processing Queue Fields
It's also possible to customize the columns shown in this view to get more information about the tasks under execution. Right click the table header to open up a menu to choose which columns are visible.