# Getting Started

## What This Project Does
This codebase is a small Java project organized around a simple `OrderService` example and a collection of test fixtures that exercise different test-detection patterns. It appears to be used to validate how source and test files are recognized across `src/main`, `src/test`, `src/utils`, and `standalone` locations.

## Recommended Reading Order
1. Read the project overview or any top-level wiki page that explains the repository’s purpose.
2. Skim the main implementation in [`src/main/java/com/example/OrderService.java`](../../src/main/java/com/example/OrderService.java).
3. Review the test fixtures in [`src/test/java/com/example/OrderServiceTest.java`](../../src/test/java/com/example/OrderServiceTest.java) and the edge cases in `src/main` and `src/utils`.
4. If you need to understand naming or classification rules, inspect the remaining fixture classes listed below.

## Key Entry Points
There are no highly-referenced classes in this repository snapshot, so the best starting point is the core service and the test fixtures around it:

- [`OrderService`](../../src/main/java/com/example/OrderService.java) — the main production class in this sample.
- [`OrderServiceTest`](../../src/test/java/com/example/OrderServiceTest.java) — the canonical test in the test tree.
- [`LegacyTest`](../../src/main/java/com/example/LegacyTest.java) — a legacy JUnit 3-style class in `src/main`.
- [`RogueTestAnnotated`](../../src/main/java/com/example/RogueTestAnnotated.java) — a production-path class with a JUnit annotation.
- [`TestNGTest`](../../src/main/java/com/example/TestNGTest.java) — a TestNG-annotated class in `src/main`.
- [`TestHelper`](../../src/main/java/com/example/TestHelper.java) — a non-test helper with a test-like name.
- [`UnannotatedInTest`](../../src/test/java/com/example/UnannotatedInTest.java) — a file under `src/test` without test annotations.
- [`ImportOnlyTest`](../../src/utils/ImportOnlyTest.java) — a utility-path file with a JUnit import only.
- [`OrderServiceTest`](../../standalone/OrderServiceTest.java) — a standalone fixture outside the normal source trees.

## Project Structure
The repository is intentionally minimal:

- `src/main/java/com/example/` contains the production-side example classes and test-like edge cases.
- `src/test/java/com/example/` contains the primary test fixture and a non-annotated file for classification checks.
- `src/utils/` contains utility-path fixtures that should not be treated as standard tests automatically.
- `standalone/` contains an isolated test-like file outside the usual Maven or Gradle source layout.

For day-to-day work, start by understanding which files are treated as real application code versus test fixtures, then trace how the project’s tooling classifies them.

## Configuration
No repository-wide build or configuration files are visible in this snapshot, so there is no obvious Maven, Gradle, or test-runner configuration to inspect yet. If you add or locate build files later, check them first for:

- source roots and test roots
- test framework dependencies
- naming or annotation-based test discovery rules
- any custom include/exclude patterns for `src/utils` or `standalone`

## Common Patterns
A few conventions show up repeatedly:

- **Small fixture classes** — classes are tiny and focused on one classification scenario.
- **Name-only vs annotation-only signals** — some files are named like tests, while others rely on annotations or directory placement.
- **Mixed framework examples** — the fixtures include JUnit 3, JUnit 4, and TestNG styles.
- **Location matters** — the same naming pattern can mean different things depending on whether the file is under `src/main`, `src/test`, `src/utils`, or `standalone`.

## Where To Go Next
If you are onboarding, the fastest way to build context is to compare the main service class with the different test fixtures and ask: “What would make this file count as a test?” That question will guide you through most of the repository’s purpose.