Computer science lab report: how to present software testing methods and results

John Carter
Written by John Carter PhD – Education
Updated November 20, 2026 10 min read
Computer science lab report: how to present software testing methods and results

A computer science lab report is a structured document describing an investigation into a program's behavior, correctness, or quality. It explains what was tested, how the tests were performed, what the results revealed, and whether the evidence supports a conclusion about software behavior. Unlike a conventional essay, a software testing lab report relies on experimental evidence: test cases, assertions, execution logs, coverage measurements, and observed defects. A passing test suite is useful, but it does not automatically prove that an application is reliable. Learning how to present software testing methods and results helps you turn raw technical output into a reproducible academic investigation.

To present software testing methods and results in a computer science lab report, document the testing environment, explain how test cases were selected and executed, and distinguish expected outcomes from actual observations. Report the results in a clearly labeled table, then analyze failures, coverage measurements, and limitations without claiming more than the evidence supports.

Understanding software testing methods

Before writing your methodology, identify which testing approaches were used and what each can demonstrate.

Unit testing

Unit tests examine small parts of a program, such as functions, calculations, or service methods.

For example, a unit test might verify that a discount calculation returns the expected value when the input is zero.

In your report, describe the tested function, input values, expected output, and actual result. Include boundary conditions and invalid inputs when relevant.

Integration testing

Integration tests examine interactions between components or services.

An Angular experiment might test whether a component correctly processes data returned by a service or responds appropriately to an HTTP error.

Document which components interact, which dependencies are real or simulated, and how the interaction is evaluated.

End-to-end testing

End-to-end testing examines complete application workflows, often through a browser.

A test might verify that users can enter information, submit a form, navigate to another page, and see the expected result.

Explain the workflow, test environment, expected behavior, and observed outcome. Browser differences and network conditions may affect reproducibility.

These methods provide different forms of evidence. A unit test can establish that a specific calculation behaves correctly without demonstrating that the complete application works.

How to structure a computer science lab report

Your instructor's requirements take priority, but most software testing reports benefit from a consistent structure.

Section What to include

Title and abstract

Experiment objective, testing approach, major findings

Introduction

Research question, background, expected behavior

Methodology

Software versions, tools, test cases, procedures

Results

Test outcomes, measurements, tables, failures

Discussion

Interpretation, limitations, implications

Conclusion

Findings supported by the evidence

References and appendices

Technical sources, code excerpts, detailed logs

The central distinction is between the methodology, which explains how testing was performed; the results, which report what happened; and the discussion, which interprets those observations.

A well-designed report answers four questions:

  1. What behavior was being investigated? Define the research question and expected outcome.
  2. How was the behavior tested? Identify the environment, tools, procedures, and test conditions.
  3. What happened? Present observations, failures, and measurements.
  4. What do the findings mean? Explain what the evidence supports and what remains uncertain.

The difference between a strong and weak report lies in the quality of its evidence, not the number of screenshots or technical terms it contains.

Writing a reproducible software testing methodology

A methodology should contain enough detail for another person to repeat the experiment under comparable conditions.

For example, an experiment might investigate whether an Angular application validates user input correctly, handles failed API requests, or maintains expected behavior after a code change.

Define the research question

Avoid objectives such as "test the application."

Instead, formulate a measurable question:

Does an Angular task-entry component reject empty input and display an appropriate message when the server returns an error?

This question identifies the application component, expected behavior, and testing conditions.

You can then establish specific acceptance criteria before examining the results.

Document the testing environment

Record the relevant software configuration, including:

  • Application and framework versions
  • Programming language and runtime
  • Testing framework and execution commands
  • Browser or simulated DOM environment
  • Mocked services and test data
  • Source-code revision or commit identifier

For modern Angular projects, the Angular CLI supports Vitest-based testing. Angular's TestBed helps configure isolated test environments, while HTTP testing utilities can simulate network responses.

Developer resources such as ng-book.com can help explain application-testing concepts, but your methodology must describe the actual configuration used in your experiment.

Explain test selection and execution

Describe why particular cases were selected.

For input validation, appropriate scenarios might include valid text, empty input, excessive length, and unexpected characters. For API interactions, examine successful responses, server errors, and unavailable resources.

Explain how tests were executed, whether they were automated, how dependencies were controlled, and whether repeated runs produced consistent outcomes.

Record the procedure before interpreting its results. Otherwise, there is a risk of selecting only favorable observations.

Example: Presenting Angular software testing results

Consider a hypothetical experiment testing an Angular task-entry component. The objective is to determine whether the interface validates input and handles failed API requests.

The following results are illustrative, not findings from an actual experiment.

Example methodology paragraph

The experiment used automated component and service tests in an Angular application. The tests examined form validation, submission behavior, and responses to simulated HTTP failures. Network responses were controlled through Angular HTTP testing utilities to avoid dependence on a live server. The suite was executed using the Angular CLI test command, with coverage reporting enabled. Expected outcomes were defined before execution and compared with recorded observations.

The methodology identifies what was investigated, how conditions were controlled, and how outcomes were evaluated.

Example results table

Test ID Test condition Expected outcome Observed outcome Status

T01

Valid task entered Task accepted Task accepted Pass

T02

Empty input submitted Validation message Message displayed Pass

T03

Task exceeds limit Input rejected Input rejected Pass

T04

Server returns HTTP 500 Error message displayed Message absent Fail

These are selected cases from a hypothetical 13-test suite.

Suppose the complete run produced:

  • 12 passed tests and 1 failed test
  • 92.3% test pass rate
  • 87% line coverage
  • 78% branch coverage

State the coverage scope and measurement method. Line coverage measures executed lines in instrumented code, while branch coverage examines whether different decision paths were exercised.

Neither percentage proves software reliability. Code may execute without its behavior being adequately checked.

Example results paragraph

Of the 13 automated checks, 12 passed and one failed, producing a pass rate of 92.3%. The failing case occurred when the application received a simulated HTTP 500 response. Although the request failed as expected, the component did not display the required error message. The measured line and branch coverage values were 87% and 78%, respectively.

Notice that this paragraph reports observations without making unsupported claims about the application's overall quality.

How to analyze and discuss testing results

The discussion section should explain what the results mean in relation to the original research question.

For the example above, an appropriate interpretation would be:

The results indicate that the tested input-validation scenarios behaved as expected, while the error-handling requirement was not satisfied. The failure suggests a problem in how the component communicates unsuccessful server responses to the user. The coverage measurements indicate that some code paths were not exercised, but they do not establish whether those paths contain additional defects.

This is analysis rather than description because it connects observations to requirements and identifies uncertainty.

A strong discussion also addresses limitations.

Mocked HTTP responses improve repeatability but cannot demonstrate that a live backend will behave identically. Tests using a simulated DOM may not expose every browser-specific problem. A limited input dataset cannot establish correctness for all possible inputs.

Distinguish these limitations from confirmed defects. A failed assertion provides evidence of a specific mismatch; an untested condition represents uncertainty.

Evaluating and citing technical evidence

A computer science report typically draws on two different evidence categories.

Primary experimental evidence includes your test logs, source code, assertions, screenshots, measurements, and observations. These support claims about your particular experiment.

Secondary technical sources include framework documentation, research publications, textbooks, and developer tutorials. They explain testing concepts, justify methodological choices, or provide technical context.

For an Angular-based investigation, official framework documentation is particularly useful for establishing how testing APIs work. Developer-oriented material can provide broader explanations and practical examples.

When citing ng-book.com or comparable programming resources, identify the relevant page and its publication or revision date when available. Distinguish historical AngularJS material from guidance for modern Angular, since testing frameworks and APIs have evolved.

Use the citation style required by your course, such as IEEE or APA. Include software versions where relevant, and identify code or documentation obtained from external sources.

Most importantly, do not present a tutorial's example output as though it came from your experiment.

Common mistakes in software testing lab reports

Several mistakes can weaken an otherwise technically competent investigation.

  • Confusing test success with complete correctness. Passing tests establish that selected assertions succeeded under specified conditions. They cannot establish that every possible behavior is correct.
  • Reporting coverage without interpretation. High coverage may coexist with weak assertions or missing edge cases. Explain what was measured and what the metric cannot demonstrate.
  • Omitting environment details. Missing framework versions, test settings, or dependency configurations make reproduction more difficult.
  • Combining results and discussion. Report observations first, then explain their significance. This separation makes your reasoning easier to assess.
  • Ignoring failed or inconsistent tests. Failed assertions and flaky behavior are important evidence. Report them transparently rather than removing unfavorable outcomes.

Drawing conclusions beyond the experiment. Testing one component under mocked conditions does not justify claiming that the entire application is production-ready.

Final checklist before submission

Before submitting your report, check that:

  • The research question and acceptance criteria are explicit.
  • The testing environment and execution procedure are reproducible.
  • Expected and observed results are clearly distinguished.
  • Tables and figures have meaningful labels.
  • Coverage values include their measurement scope.
  • Failures and limitations are disclosed.
  • Conclusions follow from recorded evidence.
  • Technical sources and reused code are appropriately acknowledged.

If you need additional guidance on organizing these sections, SpeedyPaper's lab-report writing resources can help with structure and revision while keeping the experimental findings grounded in your own work.

Need help with your physics research?
Get expert support for complex science papers
Order now

Conclusion

An effective computer science lab report transforms software testing output into a defensible technical argument.

That requires more than recording successful assertions. You must establish measurable objectives, document reproducible methods, report outcomes accurately, and explain the limitations of the evidence.

By separating observations from interpretation and supporting conclusions with specific test results, you demonstrate both an understanding of software engineering and the ability to communicate technical research clearly.

John Carter
About the author
John Carter PhD – Education
  • 8+ years of experience

John Carter is an education consultant and academic writer with a PhD in Education from Harvard. Drawing on his background in educational research and curriculum development, he writes about academic writing, essay structure, learning strategies, and effective approaches to complex academic tasks.

Specialist at: English Language Academic Writing Editing & Proofreading

Sources

  1. 1

    Testing Overview. Angular Documentation.

    https://angular.dev/guide/testing
  2. 2

    Testing Services. Angular Documentation.

    https://angular.dev/guide/testing/services
  3. 3

    Testing HTTP Requests. Angular Documentation.

    https://angular.dev/guide/http/testing
  4. 4

    Migrating from Karma to Vitest. Angular Documentation.

    https://angular.dev/guide/testing/migrating-to-vitest