requirements & test oracle

Author: ss7536

courseProjectDocs/requirements-and-oracles.md

@@ -3,28 +3,36 @@
 ## Functional Requirements
 
 The described data structures should be able to:
+
 1. **Traversal:** Enable traversal methods (e.g., in-order, pre-order, post-order for trees; forward/backward for linked lists).
 2. **Sorting:** Provide built-in or integrable sorting mechanisms where applicable.
 3. **Search & Access:** Support efficient search and retrieval of elements.
 4. **Error Handling:** Gracefully handle invalid operations (e.g., removing from an empty queue).
-
+5. **Insertion & Deletion:** Allow insertion and deletion operations at appropriate positions.
+6. **Integration with Algorithms:** Data structures shall support direct usage with sorting, searching, or graph algorithms.
 
 ## Non-Functional Requirements
 
 The data structure should ensure:
+
 1. **Testability:** Design should allow easy integration with unit testing frameworks.
 2. **Performance / Efficiency:** Operations should be optimized for time and space complexity (e.g., O(1) for stack push/pop).
 3. **Scalability:** Data structures should handle large datasets without significant performance degradation.
-
+4. **Reliability:** Functions should consistently return correct results under normal usage.
+5. **Maintainability:** Code should be modular, well-documented, and easy to update or extend.
 
 ## Test Oracles
 
-| Requirement ID | Requirement Description                                                                  | Test Oracle (Expected Behavior)                                                                                           |
-|----------------|------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------|
-| FR-1           | Enable traversal methods (e.g., in-order, pre-order, post-order for trees; forward/backward for linked lists) | Traversal methods should return elements in the correct sequence based on the traversal type.        |
-| FR-2           | Provide built-in or integrable sorting mechanisms where applicable                       | Sorting operations should generate a correctly ordered sequence of elements.                                              |
-| FR-3           | Support efficient search and retrieval of elements                                       | For a known dataset, search operations should return the correct element or index in expected time (e.g., O(log n)).      |
-| FR-4           | Gracefully handle invalid operations (e.g., removing from an empty queue)                | Invalid operations should raise appropriate exceptions or return error codes without crashing. 
-| NFR-1          | Design should allow easy integration with unit testing frameworks                        | All public methods should be testable via standard unit testing frameworks.                                               |
-| NFR-2          | Data structures should handle large datasets without significant performance degradation | Usage with large datasets should show stable performance metrics and no memory overflows or timeouts.                     |
-| NFR-3          | Operations should be optimized for time and space complexity (e.g., O(1) for stack push/pop) | Operations should meet the expected time/space complexity bounds under typical scenarios.                             |
+| Requirement ID | Requirement Description                                                                                       | Test Oracle (Expected Behavior)                                                                                      |
+| -------------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| FR-1           | Enable traversal methods (e.g., in-order, pre-order, post-order for trees; forward/backward for linked lists) | Traversal methods should return elements in the correct sequence based on the traversal type.                        |
+| FR-2           | Provide built-in or integrable sorting mechanisms where applicable                                            | Sorting operations should generate a correctly ordered sequence of elements.                                         |
+| FR-3           | Support efficient search and retrieval of elements                                                            | For a known dataset, search operations should return the correct element or index in expected time (e.g., O(log n)). |
+| FR-4           | Gracefully handle invalid operations (e.g., removing from an empty queue)                                     | Invalid operations should raise appropriate exceptions or return error codes without crashing.                       |
+| FR-5           | Allow insertion and deletion operations at appropriate positions                                              | After insertion or deletion, the data structure should reflect the updated state accurately.                         |
+| FR-6           | Data structures shall support direct usage with sorting, searching, or graph algorithms                       | The data structure should be able to produce correct results when used with algorithms like sorting, searching, etc. |
+| NFR-1          | Design should allow easy integration with unit testing frameworks                                             | All public methods should be testable via standard unit testing frameworks.                                          |
+| NFR-2          | Data structures should handle large datasets without significant performance degradation                      | Usage with large datasets should show stable performance metrics and no memory overflows or timeouts.                |
+| NFR-3          | Operations should be optimized for time and space complexity (e.g., O(1) for stack push/pop)                  | Operations should meet the expected time/space complexity bounds under typical scenarios.                            |
+| NFR-4          | Functions should consistently return correct results under normal usage                                       | Repeated calls with valid inputs should yield consistent and correct outputs.                                        |
+| NFR-5          | Code should be modular, well-documented, and easy to update or extend                                         | Code analysis and reviews should confirm modularity, ease to update, and presence of meaningful documentation.       |