7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Checker Classes

You will have to implement specific checks to highlight errors found in the source files. We provided an interface Check.java that defines a single method public Optional<Error> lint(String line, int lineNumber) . All the checkers you write should implement this interface and hence, you need to implement the lint method.

All of these should return an an Error when one is present with a custom message of your choosing to describe what the error means to the user. If the condition a Check is looking for is not present for a line, should return Optional.empty().

Other class

Error.java

public Error(int code, int lineNumber, String message)

Constructs an Error given the error code, line number and a message.

public String toString()

Returns a String representation of the error with the line number, error code and message. The representation should be formatted as (replace curly braces with the actual values)

(Line: {lineNumber}) has error code {code} {message}

public int getLineNumber()

Returns the line number of this error

public int getCode()

Returns the error code of this error

public String getMessage()

Returns the message for this error

Linter.java

public Linter(List<Check> checks)

Constructs a Linter given a list of checks to run through.

public List<Error> lint(String fileName) throws FileNotFoundException

Returns a list of all errors found.

BreakCheck class

import java.util.*;

public class BreakCheck implements Check {
public Optional<Error> lint(String line, int lineNumber) {
// Match "break" outside of comments or strings
if (line.matches("^(?!\\s*//|\\s*/\\*|\\s*\\*).*\\bbreak\\b.*")) {
return Optional.of(new Error(2, lineNumber, "Line contains 'break' keyword outside of a comment"));
}
return Optional.empty();
}
}

Error Class:

public class Error {
private final int code;
private final int lineNumber;
private final String message;

public Error(int code, int lineNumber, String message) {
this.code = code;
this.lineNumber = lineNumber;
this.message = message;
}

public String toString() {
return String.format("(Line: %d) has error code %d\n%s", lineNumber, code, message);
}

public int getLineNumber() {
return lineNumber;
}

public int getCode() {
return code;
}

public String getMessage() {
return message;
}
}

TestFile:

public class TestFile {
public static void main(String[] args) {
System.out.println("This is a really really really long line that should fail the long line check");
while (true) {
System.out.println("");
break;
}
}
}

Linter Class

import java.util.*;
import java.io.*;

public class Linter {
private final List<Check> checks;

public Linter(List<Check> checks) {
this.checks = checks;
}

public List<Error> lint(String fileName) throws FileNotFoundException {
List<Error> errors = new ArrayList<>();
File file = new File(fileName);
Scanner scanner = new Scanner(file);
int lineNumber = 0;
while (scanner.hasNextLine()) {
lineNumber++;
String line = scanner.nextLine();
for (Check check : checks) {
Optional<Error> result = check.lint(line, lineNumber);
if (result.isPresent()) {
errors.add(result.get());
}
}
}
scanner.close();
return errors;
}
}

LinterMain :

import java.util.*;
import java.io.*;

public class LinterMain {
public static final String FILE_NAME = "TestFile.java";

public static void main(String[] args) throws FileNotFoundException{
List<Check> checks = new ArrayList<>();
checks.add(new LongLineCheck());
checks.add(new BlankPrintlnCheck());
checks.add(new BreakCheck());
Linter linter = new Linter(checks);
List<Error> errors = linter.lint(FILE_NAME);
for (Error e : errors) {
System.out.println(e);
}
}
}

Check.java

import java.util.*;public interface Check {
public Optional<Error> lint(String line, int lineNumber);
}

I can't pass this check :
BreakCheck correctly tests for break statements:

Failed: Make sure that breakCheck does not only check if a line starts with a comment for the case when 'break' is in a comment. ==> expected: <true> but was: <false>

Feedback
1 2
Not yet
TESTCASES
The Error class generates errors correctly, and toString works properly
LongLineCheck correctly checks for long lines
BlankPrintInCheck correctly checks for blank printlns
BreakCheck correctly tests for break statements
Failed: /break should not be ignored ==> expected: <true> but was: <false>
Show stacktrace
The Linter class correctly parses through a file, and finds the right errors
my-check.txt is not empty
5/6 passed
x

As you read through the descriptions of each class below, you may find it helpful to refer back to the diagram
above to understand how these different classes work together.
The program is driven by a class Linter that lints a file given a list of checks. You will need to iterate through files
line by line and run checks on each line of the Java file. Like we mentioned in the background section, these checks
are completely customizable, and we've come up with 3 such checks: BreakCheck, LongLineCheck, and
BlankPrintinCheck and each check should return an Error. To define these checks in Java, we've defined an
interface called Check that these checks should implement.
Checker Classes
You will have to implement specific checks to highlight errors found in the source files. We provided an interface
Check.java that defines a single method public Optional<Error> lint(String line, int lineNumber). All
the checkers you write should implement this interface and hence, you need to implement the lint
method.
For this assignment, you'll implement the following checks:
1. LongLineCheck
• Should return an error (with a custom message) if the given line length is 100 characters or greater
Has error code 1
2. BreakCheck
• Should return an error (with custom message) if the given line contains the break keyword outside of
a single line comment (comments that start with //). i.e, we don't care about the word break inside
comments, and only in the actual java code.
• Your check should only look for break specifically in all-lowercase (so occurrences of "Break" or
"Break" outside of a single line comment should not be flagged).
▪ Note that this check is overly-simplistic in that it might flag some false uses of break such as
System.out.println("break");. You do not need to handle this case specially, you should flag
any use of the word break outside of a single line comment.
Has error code 2
3. BlankPrintlnCheck
• Should return an error (with custom message) if the given line contains the pattern
System.out.println("")
o Has error code 3

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 2 steps

SEE SOLUTION Check out a sample Q&A here

Knowledge Booster

Learn more about

Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.

Similar questions