Renaming tool: jfuzz
Test: run_jfuzz_test.py
Change-Id: I0efa31c3f1c30344c796a9077488e7e467d2456e
diff --git a/tools/javafuzz/Android.mk b/tools/jfuzz/Android.mk
similarity index 90%
rename from tools/javafuzz/Android.mk
rename to tools/jfuzz/Android.mk
index 63db57a..c7002d6 100644
--- a/tools/javafuzz/Android.mk
+++ b/tools/jfuzz/Android.mk
@@ -12,14 +12,14 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-# Java fuzzer tool.
+# Fuzzer tool.
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CPP_EXTENSION := cc
-LOCAL_SRC_FILES := javafuzz.cc
+LOCAL_SRC_FILES := jfuzz.cc
LOCAL_CFLAGS += -O0 -g -Wall
LOCAL_MODULE_HOST_OS := darwin linux windows
-LOCAL_MODULE := javafuzz
+LOCAL_MODULE := jfuzz
include $(BUILD_HOST_EXECUTABLE)
diff --git a/tools/javafuzz/README.md b/tools/jfuzz/README.md
similarity index 86%
rename from tools/javafuzz/README.md
rename to tools/jfuzz/README.md
index a70e4c1..1d566a9 100644
--- a/tools/javafuzz/README.md
+++ b/tools/jfuzz/README.md
@@ -1,19 +1,19 @@
-JavaFuzz
-========
+JFuzz
+=====
-JavaFuzz is a tool for generating random Java programs with the objective
-of fuzz testing the ART infrastructure. Each randomly generated Java program
+JFuzz is a tool for generating random programs with the objective
+of fuzz testing the ART infrastructure. Each randomly generated program
can be run under various modes of execution, such as using the interpreter,
using the optimizing compiler, using an external reference implementation,
or using various target architectures. Any difference between the outputs
(**divergence**) may indicate a bug in one of the execution modes.
-JavaFuzz can be combined with DexFuzz to get multi-layered fuzz testing.
+JFuzz can be combined with DexFuzz to get multi-layered fuzz testing.
-How to run JavaFuzz
+How to run JFuzz
===================
- javafuzz [-s seed] [-d expr-depth] [-l stmt-length]
+ jfuzz [-s seed] [-d expr-depth] [-l stmt-length]
[-i if-nest] [-n loop-nest]
where
@@ -29,17 +29,17 @@
-n : defines a fuzzing nest for for/while/do-while loops
(higher values yield deeper nested loops)
-The current version of JavaFuzz sends all output to stdout, and uses
+The current version of JFuzz sends all output to stdout, and uses
a fixed testing class named Test. So a typical test run looks as follows.
- javafuzz > Test.java
+ jfuzz > Test.java
jack -cp ${JACK_CLASSPATH} --output-dex . Test.java
art -classpath classes.dex Test
-How to start JavaFuzz testing
+How to start JFuzz testing
=============================
- run_java_fuzz_test.py
+ run_jfuzz_test.py
[--num_tests=NUM_TESTS]
[--device=DEVICE]
[--mode1=MODE] [--mode2=MODE]
@@ -56,8 +56,8 @@
tint = Art interpreter on target
topt = Art optimizing on target
-How to start Java/DexFuzz testing (multi-layered)
-=================================================
+How to start J/DexFuzz testing (multi-layered)
+==============================================
run_dex_fuzz_test.py
[--num_tests=NUM_TESTS]
@@ -67,7 +67,7 @@
where
--num_tests : number of tests to run (10000 by default)
- --num_inputs: number of JavaFuzz programs to generate
+ --num_inputs: number of JFuzz programs to generate
--device : target device serial number (passed to adb -s)
Background
diff --git a/tools/javafuzz/__init__.py b/tools/jfuzz/__init__.py
similarity index 100%
rename from tools/javafuzz/__init__.py
rename to tools/jfuzz/__init__.py
diff --git a/tools/javafuzz/javafuzz.cc b/tools/jfuzz/jfuzz.cc
similarity index 96%
rename from tools/javafuzz/javafuzz.cc
rename to tools/jfuzz/jfuzz.cc
index 161ae0a..125b56a 100644
--- a/tools/javafuzz/javafuzz.cc
+++ b/tools/jfuzz/jfuzz.cc
@@ -26,7 +26,7 @@
namespace {
/*
- * Java operators.
+ * Operators.
*/
#define EMIT(x) fputs((x)[random0(sizeof(x)/sizeof(const char*))], out_);
@@ -49,33 +49,33 @@
static constexpr const char* kRelOps[] = { "==", "!=", ">", ">=", "<", "<=" };
/*
- * Version of JavaFuzz. Increase this each time changes are made to the program
- * to preserve the property that a given version of JavaFuzz yields the same
- * fuzzed Java program for a deterministic random seed.
+ * Version of JFuzz. Increase this each time changes are made to the program
+ * to preserve the property that a given version of JFuzz yields the same
+ * fuzzed program for a deterministic random seed.
*/
const char* VERSION = "1.1";
static const uint32_t MAX_DIMS[11] = { 0, 1000, 32, 10, 6, 4, 3, 3, 2, 2, 2 };
/**
- * A class that generates a random Java program that compiles correctly. The program
+ * A class that generates a random program that compiles correctly. The program
* is generated using rules that generate various programming constructs. Each rule
* has a fixed probability to "fire". Running a generated program yields deterministic
* output, making it suited to test various modes of execution (e.g an interpreter vs.
* an compiler or two different run times) for divergences.
*
- * TODO: Due to the original scope of this project, the generated Java program is heavy
- * on loops, arrays, and basic operations; fuzzing other aspects of Java programs,
- * like elaborate typing, class hierarchies, and interfaces is still TBD.
+ * TODO: Due to the original scope of this project, the generated program is heavy
+ * on loops, arrays, and basic operations; fuzzing other aspects, like elaborate
+ * typing, class hierarchies, and interfaces is still TBD.
*/
-class JavaFuzz {
+class JFuzz {
public:
- JavaFuzz(FILE* out,
- uint32_t seed,
- uint32_t expr_depth,
- uint32_t stmt_length,
- uint32_t if_nest,
- uint32_t loop_nest)
+ JFuzz(FILE* out,
+ uint32_t seed,
+ uint32_t expr_depth,
+ uint32_t stmt_length,
+ uint32_t if_nest,
+ uint32_t loop_nest)
: out_(out),
fuzz_random_engine_(seed),
fuzz_seed_(seed),
@@ -100,7 +100,7 @@
float_local_(0),
double_local_(0) { }
- ~JavaFuzz() { }
+ ~JFuzz() { }
void emitProgram() {
emitHeader();
@@ -978,10 +978,10 @@
// Emit program header. Emit command line options in the comments.
void emitHeader() {
- fputs("\n/**\n * AOSP Java Fuzz Tester.\n", out_);
- fputs(" * Automatically generated Java program.\n", out_);
+ fputs("\n/**\n * AOSP JFuzz Tester.\n", out_);
+ fputs(" * Automatically generated program.\n", out_);
fprintf(out_,
- " * javafuzz -s %u -d %u -l %u -i %u -n %u (version %s)\n */\n\n",
+ " * jfuzz -s %u -d %u -l %u -i %u -n %u (version %s)\n */\n\n",
fuzz_seed_,
fuzz_expr_depth_,
fuzz_stmt_length_,
@@ -1101,8 +1101,8 @@
// Seed global random generator.
srand(seed);
- // Generate fuzzed Java program.
- JavaFuzz fuzz(stdout, seed, expr_depth, stmt_length, if_nest, loop_nest);
+ // Generate fuzzed program.
+ JFuzz fuzz(stdout, seed, expr_depth, stmt_length, if_nest, loop_nest);
fuzz.emitProgram();
return 0;
}
diff --git a/tools/javafuzz/run_dex_fuzz_test.py b/tools/jfuzz/run_dex_fuzz_test.py
similarity index 87%
rename from tools/javafuzz/run_dex_fuzz_test.py
rename to tools/jfuzz/run_dex_fuzz_test.py
index ff87aa4..56cdf02 100755
--- a/tools/javafuzz/run_dex_fuzz_test.py
+++ b/tools/jfuzz/run_dex_fuzz_test.py
@@ -37,14 +37,14 @@
class DexFuzzTester(object):
- """Tester that feeds JavaFuzz programs into DexFuzz testing."""
+ """Tester that feeds JFuzz programs into DexFuzz testing."""
def __init__(self, num_tests, num_inputs, device):
"""Constructor for the tester.
Args:
num_tests: int, number of tests to run
- num_inputs: int, number of JavaFuzz programs to generate
+ num_inputs: int, number of JFuzz programs to generate
device: string, target device serial number (or None)
"""
self._num_tests = num_tests
@@ -77,20 +77,20 @@
# TODO: detect divergences or shutil.rmtree(self._results_dir)
def Run(self):
- """Feeds JavaFuzz programs into DexFuzz testing."""
+ """Feeds JFuzz programs into DexFuzz testing."""
print()
- print('**\n**** JavaFuzz Testing\n**')
+ print('**\n**** JFuzz Testing\n**')
print()
print('#Tests :', self._num_tests)
print('Device :', self._device)
print('Directory :', self._results_dir)
print()
- self.GenerateJavaFuzzPrograms()
+ self.GenerateJFuzzPrograms()
self.RunDexFuzz()
- def GenerateJavaFuzzPrograms(self):
- """Generates JavaFuzzPrograms.
+ def GenerateJFuzzPrograms(self):
+ """Generates JFuzz programs.
Raises:
FatalError: error when generation fails
@@ -98,8 +98,8 @@
os.chdir(self._inputs_dir)
for i in range(1, self._num_inputs + 1):
jack_args = ['-cp', GetJackClassPath(), '--output-dex', '.', 'Test.java']
- if RunCommand(['javafuzz'], out='Test.java', err=None) != RetCode.SUCCESS:
- raise FatalError('Unexpected error while running JavaFuzz')
+ if RunCommand(['jfuzz'], out='Test.java', err=None) != RetCode.SUCCESS:
+ raise FatalError('Unexpected error while running JFuzz')
if RunCommand(['jack'] + jack_args, out=None, err='jackerr.txt',
timeout=30) != RetCode.SUCCESS:
raise FatalError('Unexpected error while running Jack')
@@ -128,7 +128,7 @@
parser.add_argument('--num_tests', default=10000,
type=int, help='number of tests to run')
parser.add_argument('--num_inputs', default=50,
- type=int, help='number of JavaFuzz program to generate')
+ type=int, help='number of JFuzz program to generate')
parser.add_argument('--device', help='target device serial number')
args = parser.parse_args()
# Run the DexFuzz tester.
diff --git a/tools/javafuzz/run_java_fuzz_test.py b/tools/jfuzz/run_jfuzz_test.py
similarity index 92%
rename from tools/javafuzz/run_java_fuzz_test.py
rename to tools/jfuzz/run_jfuzz_test.py
index 6cf3e85..cf2364b 100755
--- a/tools/javafuzz/run_java_fuzz_test.py
+++ b/tools/jfuzz/run_jfuzz_test.py
@@ -208,7 +208,7 @@
device: string, target device serial number (or None)
extra_args: list of strings, extra arguments for dalvikvm
"""
- self._test_env = DeviceTestEnv('javafuzz_', specific_device=device)
+ self._test_env = DeviceTestEnv('jfuzz_', specific_device=device)
self._dalvik_cmd = ['dalvikvm']
if extra_args is not None:
self._dalvik_cmd += extra_args
@@ -299,8 +299,8 @@
#
-class JavaFuzzTester(object):
- """Tester that runs JavaFuzz many times and report divergences."""
+class JFuzzTester(object):
+ """Tester that runs JFuzz many times and report divergences."""
def __init__(self, num_tests, device, mode1, mode2):
"""Constructor for the tester.
@@ -317,7 +317,7 @@
self._runner2 = GetExecutionModeRunner(device, mode2)
self._save_dir = None
self._results_dir = None
- self._javafuzz_dir = None
+ self._jfuzz_dir = None
# Statistics.
self._test = 0
self._num_success = 0
@@ -334,23 +334,23 @@
"""
self._save_dir = os.getcwd()
self._results_dir = mkdtemp(dir='/tmp/')
- self._javafuzz_dir = mkdtemp(dir=self._results_dir)
- if self._results_dir is None or self._javafuzz_dir is None:
+ self._jfuzz_dir = mkdtemp(dir=self._results_dir)
+ if self._results_dir is None or self._jfuzz_dir is None:
raise FatalError('Cannot obtain temp directory')
- os.chdir(self._javafuzz_dir)
+ os.chdir(self._jfuzz_dir)
return self
def __exit__(self, etype, evalue, etraceback):
"""On exit, re-enters previously saved current directory and cleans up."""
os.chdir(self._save_dir)
- shutil.rmtree(self._javafuzz_dir)
+ shutil.rmtree(self._jfuzz_dir)
if self._num_divergences == 0:
shutil.rmtree(self._results_dir)
def Run(self):
- """Runs JavaFuzz many times and report divergences."""
+ """Runs JFuzz many times and report divergences."""
print()
- print('**\n**** JavaFuzz Testing\n**')
+ print('**\n**** JFuzz Testing\n**')
print()
print('#Tests :', self._num_tests)
print('Device :', self._device)
@@ -360,7 +360,7 @@
print()
self.ShowStats()
for self._test in range(1, self._num_tests + 1):
- self.RunJavaFuzzTest()
+ self.RunJFuzzTest()
self.ShowStats()
if self._num_divergences == 0:
print('\n\nsuccess (no divergences)\n')
@@ -378,8 +378,8 @@
end='')
sys.stdout.flush()
- def RunJavaFuzzTest(self):
- """Runs a single JavaFuzz test, comparing two execution modes."""
+ def RunJFuzzTest(self):
+ """Runs a single JFuzz test, comparing two execution modes."""
self.ConstructTest()
retc1 = self._runner1.CompileAndRunTest()
retc2 = self._runner2.CompileAndRunTest()
@@ -387,13 +387,13 @@
self.CleanupTest()
def ConstructTest(self):
- """Use JavaFuzz to generate next Test.java test.
+ """Use JFuzz to generate next Test.java test.
Raises:
- FatalError: error when javafuzz fails
+ FatalError: error when jfuzz fails
"""
- if RunCommand(['javafuzz'], out='Test.java', err=None) != RetCode.SUCCESS:
- raise FatalError('Unexpected error while running JavaFuzz')
+ if RunCommand(['jfuzz'], out='Test.java', err=None) != RetCode.SUCCESS:
+ raise FatalError('Unexpected error while running JFuzz')
def CheckForDivergence(self, retc1, retc2):
"""Checks for divergences and updates statistics.
@@ -477,8 +477,8 @@
def CleanupTest(self):
"""Cleans up after a single test run."""
- for file_name in os.listdir(self._javafuzz_dir):
- file_path = os.path.join(self._javafuzz_dir, file_name)
+ for file_name in os.listdir(self._jfuzz_dir):
+ file_path = os.path.join(self._jfuzz_dir, file_name)
if os.path.isfile(file_path):
os.unlink(file_path)
elif os.path.isdir(file_path):
@@ -498,8 +498,8 @@
args = parser.parse_args()
if args.mode1 == args.mode2:
raise FatalError('Identical execution modes given')
- # Run the JavaFuzz tester.
- with JavaFuzzTester(args.num_tests, args.device,
+ # Run the JFuzz tester.
+ with JFuzzTester(args.num_tests, args.device,
args.mode1, args.mode2) as fuzzer:
fuzzer.Run()