LogoLogo
Product
  • Knowledge Base
  • What's New
  • Guides
  • User Story Coverage
    • Getting Started
    • User Story Challenges & Solution
      • Typical Implementation
      • The Challenges
      • The Solution
    • User Story Coverage Report Overview
      • Release Go / No Go Report
        • How to Generate / Edit the Report
      • User Story Quality Overview
        • How to Generate the User Story View
      • User Story Coverage Analysis
        • How to Generate the Analysis View
      • Uncovered Methods View
        • How to Generate the View
      • Customization
      • Integration
    • Use Cases by Persona
      • Managers
        • Informed Go/No Go Decisions Making
        • Effective Resources Prioritization
        • Overall Progress Monitoring
      • Developers
        • Code Quality Ownership
        • Seamless Collaboration with QA
        • Code Review Facilitator
      • QA Engineers
        • Test Execution Progress Monitoring
        • Testing Effort Prioritization
        • Testing Strategy Planing
    • Technical Overview
      • User Story Coverage Mechanism
      • Technical Architecture
      • Deployment Guide
        • US1_getResults.sh
        • US2_createReport.sh
        • US_UpdateConfluence.sh
  • Test Optimization
    • Getting Started
    • Test Execution Challenges & Solution
      • The Challenges
      • Test Optimization Solution
      • Test Optimization Main Advantages
    • Test Optimization Overview
      • Automated Test Optimization
      • Manual Test Optimization
      • Test Optimization for Pull Request
      • Test Selection Policies
        • Full Run Policy
        • No Code Changes Policy
        • Common Code Policy
        • Fastest Path to 100% Coverage Policy
      • Integrations
    • Use Cases by Persona
      • Managers
        • Fast Delivery
        • Resource Optimization
        • Thorough Testing in Tight Schedule
      • Developers
        • Exploring Only Relevant Test Failures
        • Faster Feedback Loop
        • Shift Left Testing
      • QA Engineers & Manual Testers
        • Faster & Focused Manual Testing
        • Optimizing Test Suite
        • Having Stable Product for Testing
    • Technical Overview
      • Test Optimization Mechanism
        • Associating Code With Tests
          • Statistical modeling
          • One-to-One Mapping
          • Calibration
        • Detecting Modified Code
        • Generating Test Recommendations
      • Technical Architecture
      • Deployment Guide
  • Quality Improvement
    • Getting Started
    • Challenges & Approach Comparison
      • The Challenges
      • Quality Improvement Approaches
      • Choosing the Right Approach
    • Quality Improvement Solution Overview
      • Test Gaps Analysis Report
        • How to Generate / Edit the Report
      • Coverage Trend Report
        • How to Generate / Edit the Report
      • Proof of Testing Report
        • How to Generate / Edit the Report
      • Release Quality Improvement Guide
        • STEP 1: Deploy SeaLights
        • STEP 2: Take a Quality Snapshot
        • STEP 3: Prioritize Code Areas
          • Add Code Labels
          • Ignore Irrelevant Code
          • Perform a Deep CSV Analysis
        • STEP 4: Set Baseline & Threshold
        • STEP 5: Analyze Test Gaps
        • STEP 6: Write Tests
        • Step 7: Make a Go / No Go Decision Based on Quality Gate
        • STEP 8: Measure Defect Escape Rate
      • Over Time Quality Improvement Guide
        • STEP 1: Deploy SeaLights
        • STEP 2: Take a Quality Snapshot
        • STEP 3: Prioritize code areas
          • Add Code Labels
          • Ignore Irrelevant Code
          • Perform a Deep CSV Analysis
        • STEP 4: Set Baseline & Goal
        • STEP 5: Set timeline
        • STEP 6: Write tests
        • STEP 7: Monitor progress
        • STEP 8: Measure Defect Escape Rate
    • Use Cases by Persona
      • Managers
        • Effective Prioritization & Budget Allocation
        • Tracking Progress & Measuring Impact
        • Data-Driven Release Decisions
        • Transparency & Communication
      • Developers
        • Mastering Code Coverage
        • Seamless Collaboration with QA
        • Code Quality Ownership
      • QA Engineers
        • Prioritizing Test Efforts
        • Contributing to Release Informed Decisions
        • Seamless Collaboration with Developers
        • Evaluating Testing Strategy
    • Technical Overview
      • Solution Mechanism
      • Technical Architecture
      • Deployment Guide
  • Value Proposition
    • Overview
    • Quality Use Cases
      • Go/No Go Decisions
      • Quality Improvement & Test Gaps
      • Governance & Quality Gates
      • Compliance & Proof of Testing
    • Test Optimization Use Cases
      • Reduce Costs & Infrastructure
      • Shorten Release Cycles
      • Reduce Troubleshooting
Powered by GitBook
On this page
  • Global App-Level Code Scope
  • File-Level Code Scope
  • Method-Level Code Scope

Was this helpful?

  1. Quality Improvement
  2. Quality Improvement Solution Overview
  3. Over Time Quality Improvement Guide
  4. STEP 3: Prioritize code areas

Ignore Irrelevant Code

PreviousAdd Code LabelsNextPerform a Deep CSV Analysis

Was this helpful?

SeaLights' Code Scope empowers you to tailor your quality analysis. Define inclusion and exclusion rules to analyze specific code areas, prioritizing relevant sections and streamlining testing (e.g., excluding legacy code you are not interested in getting coverage for). By default, the entire app's code is included. There are three ways to set Code Scope: app level, file level and method level.


Global App-Level Code Scope

Each application has a built-in "Global Code Entities Rule" that intelligently excludes certain method-level elements based on the app's programming language. This typically includes:

  • Auto-Generated Code: Eliminate noise from code that isn't manually written.

  • Getters and Setters: Focus on core logic instead of routine property access.

  • Constructors: Simplify analysis by excluding default object creation methods.

  • Deprecated Code: Avoid analyzing outdated and potentially unsafe sections.

  • Anonymous Methods: Streamline analysis by excluding methods defined directly within blocks of code.

By fine-tuning this global rule, you establish a solid foundation for focused and efficient analysis, ensuring that your efforts are directed toward the most impactful areas of your codebase.

Follow these steps for customization
  1. Access the "Code Scope" page within "Settings".

  2. Locate the relevant application.

  3. Review the pre-checked code entities excluded by default.

  4. Personalize your analysis:

    • Check additional entities for exclusion.

    • Uncheck entities you wish to include.

.


File-Level Code Scope

SeaLights' Code Scope offers granular control at the file level. This enables you to find a sweet spot between accuracy and maintenance, tailoring your analysis to focus on critical sections while keeping management manageable. Rule types:

  • Include: Focuses analysis on specific code areas. Ideal for analyzing smaller scopes or excluding irrelevant sections. For example, If you want to analyze the coverage for API tests, create an "Include" rule for this particular test stage that targets only the files relevant for those APIs.

  • Ignore: Removes specific code from analysis, streamlining your focus. For example, excluding legacy code you are not interested in getting coverage for.

Rule Conflicts:

Please note that when defining both "Include" and "Ignore" rules for the same code scope, the "Ignore" rule will take precedence. This ensures you have clear control over what gets excluded from your analysis.

Newly added files within a scoped folder automatically adhere to the defined rules, ensuring your analysis stays up-to-date. No need to manually update every time your codebase changes!

Follow these steps for customization
  1. Navigate to the "Code Scope" page within "Settings".

  2. Select the relevant application.

  3. Define include / ignore rules for individual test stages or all stages collectively, customizing your analysis to specific testing needs. Define multiple rules per app/stage (order doesn't matter).

  4. Leverage the flexibility to edit, duplicate and delete rules.


Method-Level Code Scope

SeaLights' Code Scope offers fine-grained method-level exclusions directly within the Test Gaps Analysis report. You can pinpoint individual methods, mark them for exclusion as needed and focus your analysis on truly relevant code.

Excluded methods automatically become "Ignore" rules in the Code Scope settings, ensuring your analysis adapts effortlessly as your codebase evolves.

Note! Excluded methods remain visible in the report but are marked as ignored for clarity.

Follow these steps for customization
  1. From the Test Gaps Analysis report drill down to a specific file with untested methods.

  2. Select specific methods you want to exclude from analysis.

  3. These exclusions are automatically reflected as "Ignore" rules under the relevant app in the Code Scope settings page.

  4. You can easily review or delete these rules as needed.


Keep in mind! Code Scope rules take effect from the next reported build in SeaLights.

By defining Code Scope, you can tailor the analysis to specific code areas, gain valuable insights into software quality, and focus on improving the most critical sections of your codebase.