代做data程序、代写Java程序设计

日期：2023-10-05 10:14

MP2: Design Patterns

1 Introduction

Since you are now familiar with the Jsoup project (at least you know how to build it ¨⌣), let’s

practice program analysis on the Jsoup project!

Imagine you are a software engineer working on a large project, there will be various programming

tasks you need to daily perform, including understanding existing code, modifying existing code, and

of course produce new code. As a graduate student in CS, you probably are already very good at such

tasks as you have learnt such skills from various courses. Meanwhile, other courses mainly teach you

how to automate various tasks in our daily life (such as financial services, transportation, healthcare,

and more) via programming, and you still have to manually perform those programming tasks. In

contrast, with program analysis, you can further automate programming tasks themselves!

2 Instructions

JavaParser (https://javaparser.org/) is a widely used analysis engine for Java programs. It

can transform any Java source code snippet into its abstract syntax tree (AST) form. Then, we can

build programs to traverse the ASTs to perform various code parsing, manipulation, and generation

tasks at the AST level. Note that JavaParser is largely built based on the Visitor design pattern

(https://en.wikipedia.org/wiki/Visitor_pattern). Here are also some useful links for getting

started with JavaParser:

• https://javaparser.org/: JavaParser homepage with various useful resources, including blogs

on how to use JavaParser in various ways.

• https://javadoc.io/doc/com.github.javaparser/javaparser-core/latest/index.html: JavaDoc

information for all JavaParser APIs.

• https://gitter.im/javaparser/home: the gitter channel for JavaParser, where you can ask

questions and search previously solved questions.

• https://tomassetti.me/wp-content/uploads/2017/12/JavaParser-JUG-Milano.pdf: a tutorial about JavaParser.

To simulate real-world software development, in this homework, you are expected to get familiar with the popular JavaParser analysis engine by yourself, and perform the following three tasks.

To simplify the implementation and auto-grading, you will revise an existing template Maven-based

project. You can download the template project using the command below:

git clone https://github.com/uiuc-cs427-f23/cs427-hw2

Note that the template project already includes the dependency of a popular JavaParser version

on Maven Central Repo. Furthermore, all the source code for Jsoup (which will be used as the

input data) has also already been included as test resources, which will be automatically copied into

target/test-classes directory during mvn test. Therefore, you do not need to install or change

anything for the project, except adding your implementation to the locations with “TODO” comments

(details will be shown in the later task description).

Your implementation should be able to pass all JUnit tests included in the edu.illinois.cs.analysis

package of the template project. You can run tests via mvn test command or through the IDE.

If you execute the tests through the command line, you can look at the generated Surefire report

(target/surefire-reports) for the details about your test failure(s), if any. Note that at the beginning, all the tests will fail, as the code is incomplete and cannot produce the expected results.

1

2.1 Task 1: Parsing existing code

Assuming you are working on the Jsoup project, and one day your manager asks you to compute

some statistics (such as the number of classes or methods) of the project. Of course, you have multiple

options even without knowing the concept of program analysis:

• Just do it manually. However, this will cost you forever in case of huge projects.

• Write some simple scripts based on string processing. It also works, but will take you a tremendous amount of time to consider all corner cases.

• Try to find some existing tools. Depending on the specific statistics, you may not find an ideal

tool that can compute all statistics.

In this task, you are expected to compute the number of methods satisfying ALL of the following

conditions within a java file based on the JavaParser program analysis tool:

• The method has actual body declaration (i.e., for method declaration n: n.getBody().isPresent()

should be true).

• The method has at least one input parameter.

• The method is public.

• The method is not static.

• The method has a return type, i.e., not void.

More specifically, you are expected to complete the TODO portions in the edu.illinois.cs.analysis.CodeParser

class so that it can automatically compute the precise number of methods. By default, it only computes the total number of methods within a file. When you are done with this task, make sure your

implementation passes all JUnit tests included in the edu.illinois.cs.analysis.CodeParserTest

class of the template project.

When you are done with the task, please also take a moment to think about the benefits of using

such a program analysis engine compared with all the other three ways for completing the same task.

It could save you even more time for a more complicated or specialized code-parsing task!

2.2 Task 2: Modifying existing code

Another day, your manager asks you to find all instances of null checks in any given Java file, and

then switch the operands for all found null checks (what a weird request! ¨⌣). Note that you shall

consider ANY binary expression that:

• includes null as an operand (either left or right side), and

• includes == or != as the operator.

You are expected to complete the TODO portions in the edu.illinois.cs.analysis.CodeModifier

class so that it can automatically make the change. When you are done with this task, make sure your

implementation passes all JUnit tests included in the edu.illinois.cs.analysis.CodeModifierTest

class of the template project.

2.3 Task 3: Generating new code

Yet another day, your manager comes and asks you to build a program that can automatically

generate the following method and add it to any given class:

2

@Override

public String toString() {

String str = super.toString();

int len=str.length();

if (len > 40)

return "OMITTED";

else

return str;

}

The reason for the change is that the original toString method (e.g., inherited from class Object)

may return very long string and cram the hard drive with large chunk of such log data. The new

toString method simply return “OMITTED” for any class with string representation longer than 40. In

this way, the space issue can be mitigated. You can assume that the given Java file does not include

toString declarations before your change (so you can directly add it without any check). You also do

not need to worry about the precision issue caused by the string omission.

You are expected to complete the TODO portions in the edu.illinois.cs.analysis.CodeGenerator

class so that it can automatically add the desired code for the given class. To help with your implementation, we have included partial implementation. Furthermore, we have also included the AST

tree information for the body of added method; you may find it helpful to follow this tree structure

to construct the corresponding code structure. You can also create the AST tree yourself by running the main method from class edu.illinois.cs.analysis.CodeGenerator. The execution will

dump a file named ast.dot in the root directory of this template project. You can simply copy the

file content and display it using any GraphViz software (e.g., you can also use the online version:

https://dreampuf.github.io/GraphvizOnline).

Figure 1: AST of the code to be generated

3 Deliverables

You are expected to upload a zip file including only the CodeParser.java, CodeModifier.java,

and CodeGenerator.java files you completed (no folders please). The name of the zip file should be

your NetID.

Warning: you may lose all your points if you violate the following rules:

• Please make sure that your zip file is named with your NetID and only includes the three specified

files: DO NOT include any folders in the zip file, and DO NOT change anything (including names) of the three files except the TODO parts.

• Please DO NOT use any absolute paths in your solution since your absolute paths will not

match our grading machines. Also, please only use “/” as the file separator in your relative

paths (if needed for this MP) since Java will usually make the correct conversions if you use the

Unix file separator “/” in relative paths (for both Windows and Unix-style systems).

3

• Please DO NOT fork any assignment repo from our GitHub organization or share your

solution online.

4 Grading rubric

The autograder will run tests on your submitted code and your final score for this MP will be based

on the success rate of test execution (including the 5 provided tests plus 5 hidden tests). The overall

score is 5pt:

• In general, your score will be proportional to the total pass rate, e.g., if you pass 8 out of the 10

tests, you will receive 4pt.

• However, we may manually check the actual code for some sampled solutions (those with more

hidden tests failing will get a higher chance to be sampled), and your score can be proportional

to your test pass rate or (very likely) lower.

4