CS6300 edittxt Utility Implementation Guide

Introduction: The edittxt Utility and Your CS6300 Journey

Welcome to the CS6300 Individual Project Deliverable 3! In this assignment, you will implement the edittxt utility in Main.java, building on the test cases you created in Deliverable 2. This tutorial will guide you through the key aspects of the implementation, test preservation, and submission process. With the final deadline approaching on May 8, 2026, it's time to ensure your code is robust and passes both your own tests and the additional tests from your team.

Understanding the Assignment Requirements

The core requirement is to provide a working implementation of the edittxt utility that passes all of your D2 test cases (without modifying the passing ones) and also passes a set of additional tests created independently by a teammate. The reference implementation from D2 serves as a benchmark, so your tests should be compatible with that. Key points to remember:

Do not modify or delete any of your passing D2 tests. You may only modify or delete tests that did not pass in D2.
You may append new tests to MyMainTest to improve coverage.
Avoid using System.exit() in your tests, as it interferes with JUnit.
Your implementation can use additional classes or files, but MyMainTest must be self-contained.

Step 1: Setting Up Your Environment

Before diving into the code, ensure your project structure is correct. You should have the following directories:

src/edu/gatech/seclass/edittxt/Main.java
test/edu/gatech/seclass/edittxt/MyMainTest.java
lib/ (contains JUnit and other dependencies)

Compile your code using the provided command:

javac -cp lib/* -d classes src/edu/gatech/seclass/edittxt/*.java test/edu/gatech/seclass/edittxt/*.java

Then run your tests locally to verify they pass:

java -cp classes:lib/* org.junit.platform.console.ConsoleLauncher --select-class edu.gatech.seclass.edittxt.MyMainTest

This local testing is crucial before pushing to Gradescope. Think of it like a beta test for a new AI app feature—you want to catch bugs early.

Step 2: Implementing the edittxt Utility

Your Main.java should parse command-line arguments and perform text editing operations. The exact operations are defined by the test cases, but common functionalities include:

Reading input from a file or standard input
Applying transformations like substitution, deletion, or insertion
Writing output to a file or standard output

For example, a typical test might expect that running java edu.gatech.seclass.edittxt.Main -i input.txt -o output.txt -s "old" "new" replaces all occurrences of "old" with "new" in the input file and writes the result to the output file. Your implementation must handle edge cases like empty files, multiple flags, and special characters.

Parsing Command-Line Arguments

Use a robust argument parser. Consider using a library like Apache Commons CLI (if allowed) or implement a simple parser yourself. A common pitfall is the order of arguments—remember that the assignment mentions that "-i" can be a parameter for "-k" if parsed incorrectly. Ensure your parser handles flags and their values correctly.

// Example argument parsing snippet
String inputFile = null;
String outputFile = null;
for (int i = 0; i < args.length; i++) {
    if (args[i].equals("-i")) {
        inputFile = args[++i];
    } else if (args[i].equals("-o")) {
        outputFile = args[++i];
    }
    // ... handle other flags
}

Step 3: Preserving Your D2 Tests

One of the most critical rules: do not modify your passing D2 tests. If you later realize a passing test is inadequate, you must append a new improved test instead of editing the old one. This is to ensure fairness in grading. For example, if your D2 test only checks a single line, add a new test that checks multiple lines or special characters.

Use git diff to compare your D2 and D3 submissions to verify no changes were made to passing tests. This is like a version control audit used in software development to track changes.

Step 4: Writing Additional Tests

Append new tests to MyMainTest to cover scenarios you might have missed. Consider edge cases such as:

Empty input file
Very large files (performance)
Special characters (newlines, tabs, Unicode)
Multiple flags combined
Invalid arguments (graceful error handling)

Your tests should be self-contained and not rely on external resources. Use @Test annotations and JUnit assertions like assertEquals.

@Test
public void testMultipleReplacements() {
    // Arrange: create temporary input file
    // Act: run edittxt with arguments
    // Assert: compare output with expected
}

Step 5: Submitting to Gradescope

When you submit, Gradescope will compile your code and run both your tests and the additional tests. If compilation fails or any test fails, you'll see a grade of 0 with diagnostic information. The autograder displays newlines as "↵", tabs as "⇥", and spaces as regular spaces to make output readable.

If you receive a failing test, analyze the diff carefully. For example, if expected output is "Hello, world!" but you got "Hello,world!" (missing space), check your replacement logic. You can resubmit as many times as needed before the deadline.

Common Pitfalls and How to Avoid Them

Modifying passing tests: Use git diff to double-check.
Using System.exit(): This can cause JUnit to abort. Use exceptions instead.
Incorrect argument parsing: Test with various flag combinations.
Not handling platform-specific line separators: Use System.lineSeparator() in tests.

Conclusion: Deliverable 3 Success

By following this guide, you'll be well-prepared to implement the edittxt utility and pass all tests. Remember to focus on test preservation, robust argument parsing, and thorough testing. Good luck, and may your Gradescope submission be green! If you encounter issues, post privately on Ed Discussion with detailed information about the test, expected vs actual output, and your code snippet. The faster you provide self-contained information, the quicker the teaching staff can help.

Pro Tip: Think of this assignment like developing a feature for a popular note-taking app—your utility must handle user input reliably and gracefully. Just as AI-powered apps need rigorous testing before release, your edittxt implementation must pass all scenarios to earn full credit.