Renaming tool: jfuzz

Test: run_jfuzz_test.py

Change-Id: I0efa31c3f1c30344c796a9077488e7e467d2456e

6 files changed, 69 insertions, 69 deletions

diff --git a/tools/javafuzz/Android.mk b/tools/jfuzz/Android.mk
index 63db57ab18..c7002d67ec 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
index a70e4c117f..1d566a94c8 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 @@ where
     -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 @@ where
       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 @@ How to start Java/DexFuzz testing (multi-layered)
 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
index 3955c712ab..3955c712ab 100644
--- a/tools/javafuzz/__init__.py
+++ b/tools/jfuzz/__init__.py
diff --git a/tools/javafuzz/javafuzz.cc b/tools/jfuzz/jfuzz.cc
index 161ae0a178..125b56a833 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* kBoolRelOps[] = { "==", "!=" };
 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 @@ class JavaFuzz {
         float_local_(0),
         double_local_(0) { }
 
-  ~JavaFuzz() { }
+  ~JFuzz() { }
 
   void emitProgram() {
     emitHeader();
@@ -978,10 +978,10 @@ class JavaFuzz {
 
   // 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 @@ int32_t main(int32_t argc, char** argv) {
   // 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
index ff87aa41f0..56cdf02d15 100755
--- a/tools/javafuzz/run_dex_fuzz_test.py
+++ b/tools/jfuzz/run_dex_fuzz_test.py
@@ -37,14 +37,14 @@ from common.common import RunCommand
 
 
 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 @@ class DexFuzzTester(object):
     # 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 @@ class DexFuzzTester(object):
     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 @@ def main():
   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
index 6cf3e85684..cf2364b5e6 100755
--- a/tools/javafuzz/run_java_fuzz_test.py
+++ b/tools/jfuzz/run_jfuzz_test.py
@@ -208,7 +208,7 @@ class TestRunnerArtOnTarget(TestRunner):
       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 TestRunnerArtOptOnTarget(TestRunnerArtOnTarget):
 #
 
 
-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 @@ class JavaFuzzTester(object):
     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 @@ class JavaFuzzTester(object):
     """
     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 @@ class JavaFuzzTester(object):
     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 @@ class JavaFuzzTester(object):
           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 @@ class JavaFuzzTester(object):
     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 @@ class JavaFuzzTester(object):
 
   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 @@ def main():
   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()