Esempio n. 1
0
public class MainTest {
  private static final File programs_location = FileUtils.absoluteResourcePath("syntax");
  private static final File programs_c_location = FileUtils.absoluteResourcePath("c");
  private static final File bad_programs_location = new File(programs_location, "bad");
  private static final File mini_programs_location = new File(programs_c_location, "mini_bnc");
  private static final File nec_programs_location = new File(programs_c_location, "nec_bnc");
  private static final File nec_inline_programs_location =
      new File(programs_c_location, "nec_inline_bnc");

  private static final File sv_programs_location =
      new File(System.getProperty("user.dir"), "../../benchmarks/sv_bnc");

  private static final FilenameFilter cFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith(".c");
        }
      };

  private static final FilenameFilter iFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith(".i");
        }
      };

  private static final FilenameFilter falseDerefFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith("_false-valid-deref.c");
        }
      };

  private static final FilenameFilter falseFreeFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith("_false-valid-free.c");
        }
      };

  private static final FilenameFilter falseMemtrackFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith("_false-valid-memtrack.c");
        }
      };

  private static final FilenameFilter falseAssertFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith("_false-valid-assert.c");
        }
      };

  private static final FilenameFilter propFileFilter =
      new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return name.endsWith(".properties");
        }
      };

  private void runCascade(final String... args) throws Exception {
    System.out.println("runCascade: " + Joiner.on(";").join(args));
    TestUtils.callMayExit(
        new Callable<Void>() {
          @Override
          public Void call() throws Exception {
            Preferences.clearAll();
            Main main = getInjector().getInstance(Main.class);
            main.init();
            List<String> files = main.processCommandLine(args);
            main.setOutStream(IOUtils.NULL_PRINT_STREAM);
            main.setErrStream(System.err);
            main.setStatsStream(System.err);
            main.run(files);
            return null;
          }
        });
  }

  private void runCascadeTO(final String... args) throws Exception {
    System.out.println("runCascade with timeout " + "20s: " + Joiner.on(";").join(args));
    TestUtils.callWithTimeout(
        new Runnable() {
          @Override
          public void run() {
            Preferences.clearAll();
            try {
              Main main = getInjector().getInstance(Main.class);
              main.init();
              List<String> files = main.processCommandLine(args);
              main.setOutStream(System.out);
              main.setErrStream(IOUtils.NULL_PRINT_STREAM);
              IOUtils.enableOut();
              main.run(files);
            } catch (TheoremProverException e) {
              e.printStackTrace();
            } catch (IOException e) {
              e.printStackTrace();
            } catch (ParseException e) {
              e.printStackTrace();
            }
          }
        },
        20);
  }

  private TestUtils.Tester<File> parserTest(final String... args) {
    return new TestUtils.Tester<File>() {
      @Override
      public void runTest(File f) {
        try {
          List<String> argList = Lists.newArrayList(args);
          argList.add(f.toString());
          runCascade(argList.toArray(new String[0]));
        } catch (ParseException e) {
          throw new AssertionError(e);
        } catch (Throwable e) {
          throw new RuntimeException(e);
        }
      }
    };
  }

  private TestUtils.Tester<File> parserTestTimeout(final String... args) {
    return new TestUtils.Tester<File>() {
      @Override
      public void runTest(File f) {
        try {
          List<String> argList = Lists.newArrayList(args);
          argList.add(f.toString());
          runCascadeTO(argList.toArray(new String[0]));
        } catch (Throwable e) {
          throw new RuntimeException(e);
        }
      }
    };
  }

  @Test(expected = ExitException.class)
  public void testHelp() throws Exception {
    runCascade(new String[] {"--help"});
  }

  @Test(expected = ExitException.class)
  public void testVersion() throws Exception {
    runCascade(new String[] {"--version"});
  }

  @Test
  public void testPrograms() {
    TestUtils.checkDirectory(programs_location, cFileFilter, parserTest("--parsec"), false);
  }

  @Test
  public void testProgramsNoThreads() {
    TestUtils.checkDirectory(
        programs_location, cFileFilter, parserTest("--parsec", "--no-threads"), false);
  }

  @Test
  public void testBadPrograms() {
    TestUtils.checkDirectory(bad_programs_location, cFileFilter, parserTest("--parsec"), true);
  }

  @Test
  public void testBadProgramsNoThreads() {
    TestUtils.checkDirectory(
        bad_programs_location, cFileFilter, parserTest("--parsec", "--no-threads"), true);
  }

  @Test
  public void testProperties() {
    TestUtils.checkDirectory(bad_programs_location, propFileFilter, parserTest("--prop"), true);
  }

  @Test
  public void testDryRun() {
    TestUtils.checkDirectory(programs_location, cFileFilter, parserTest("--dry-run"), false);

    TestUtils.checkDirectoryRec(
        mini_programs_location, cFileFilter, parserTest("--dry-run", "--iter-times", "1"), false);

    TestUtils.checkDirectoryRec(
        mini_programs_location,
        cFileFilter,
        parserTest("--dry-run", "--iter-times", "1", "--lambda"),
        false);

    TestUtils.checkDirectoryRec(
        mini_programs_location,
        cFileFilter,
        parserTest("--dry-run", "--multi-cell", "--iter-times", "1"),
        false);

    TestUtils.checkDirectoryRec(
        mini_programs_location,
        cFileFilter,
        parserTest("--dry-run", "--multi-cell", "--iter-times", "1", "--lambda"),
        false);
  }

  @Test
  @Ignore
  public void testFieldSensitive() {
    File invalid_programs_location = new File(mini_programs_location, "invalid");
    File valid_programs_location = new File(mini_programs_location, "valid");
    Tester<File> tester =
        parserTestTimeout(
            "--inline-anno",
            "--iter-times",
            "10",
            "--vari-cell",
            "--lambda",
            "--memory-check",
            "--hoare",
            "--fs",
            "-m32");

    TestUtils.checkDirectoryRec(invalid_programs_location, cFileFilter, tester, false);
    TestUtils.checkDirectoryRec(valid_programs_location, cFileFilter, tester, false);
  }

  @Test
  @Ignore
  public void testReachability() {
    File bv_programs_location = new File(sv_programs_location, "bitvector");
    File bv_reg_programs_location = new File(sv_programs_location, "bitvector-regression");

    TestUtils.checkDirectoryRec(
        bv_programs_location,
        iFileFilter,
        parserTestTimeout(
            "-r", "ERROR", "--multi-cell", "--iter-times", "10", "--function-inline", "2"),
        false);
    TestUtils.checkDirectoryRec(
        bv_reg_programs_location,
        iFileFilter,
        parserTestTimeout(
            "-r", "ERROR", "--multi-cell", "--iter-times", "10", "--function-inline", "2"),
        false);
  }

  @Test
  @Ignore
  public void testMemorySafety() {
    File memsafety_programs_location = new File(sv_programs_location, "memsafety");

    TestUtils.checkDirectoryRec(
        memsafety_programs_location,
        iFileFilter,
        parserTestTimeout(
            "--memory-check",
            "--lambda",
            "--hoare",
            "--multi-cell",
            "--iter-times",
            "10",
            "--function-inline",
            "2"),
        false);
  }

  @Test
  @Ignore
  public void testNecBenchmarkDry() {
    final Tester<File> SoundTester = parserTestTimeout("--dry-run");
    TestUtils.checkDirectoryRec(nec_programs_location, cFileFilter, SoundTester, false);
  }

  @Test
  //  @Ignore
  public void testCFSMiniBenchmark() {
    final Tester<File> SoundTester =
        parserTestTimeout(
            "--inline-anno",
            "--iter-times",
            "10",
            "-m32",
            "--vari-cell",
            "--lambda",
            "--memory-check",
            "--hoare",
            "-cfs");

    File invalid_location = new File(mini_programs_location, "invalid");
    File valid_location = new File(mini_programs_location, "valid");

    TestUtils.checkDirectoryRec(invalid_location, falseDerefFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(invalid_location, falseFreeFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(invalid_location, falseMemtrackFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(invalid_location, falseAssertFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(valid_location, cFileFilter, SoundTester, false);
  }

  @Test
  // @Ignore
  public void testCFSCSMiniBenchmark() {
    final Tester<File> SoundTester =
        parserTestTimeout(
            "--inline-anno",
            "--iter-times",
            "10",
            "-m32",
            "--vari-cell",
            "--lambda",
            "--memory-check",
            "--hoare",
            "-cfscs");

    File invalid_location = new File(mini_programs_location, "invalid");
    File valid_location = new File(mini_programs_location, "valid");

    TestUtils.checkDirectoryRec(invalid_location, falseDerefFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(invalid_location, falseFreeFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(invalid_location, falseMemtrackFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(invalid_location, falseAssertFileFilter, SoundTester, false);
    TestUtils.checkDirectoryRec(valid_location, cFileFilter, SoundTester, false);
  }

  @Test
  @Ignore
  public void testNecInlineBenchmarkDry() {
    final Tester<File> SoundTester = parserTestTimeout("--dry-run", "--inline-anno");
    TestUtils.checkDirectoryRec(nec_inline_programs_location, cFileFilter, SoundTester, false);
  }
}
Esempio n. 2
0
public class ControlFileTest {
  public static final File programs_location = FileUtils.absoluteResourcePath("syntax");
  public static final File bad_programs_location = FileUtils.filePath(programs_location, "bad");

  private void checkPosition(Position p) {
    assertNotNull("No File for Position", p.getFile());
    assertNotNull("No LineNum for Position", p.getLine());
    List<Command> cmds = p.getCommands();
    for (Command c : cmds) {
      assertNotNull("No CascadeFunction for Command", c.getCascadeFunction());
      assertNotNull("No Argument for Command", c.getArgument());
    }
  }

  /**
   * Try to parse the program, given a filename
   *
   * @param file
   */
  private void parseFromFile(File file) {
    // System.out.print("Parsing " + file + " ... ");
    try {
      ControlFile cf = ControlFile.fromXml(file);
      /*
       * Validate that the ControlFile object has the expected fields populated:
       * 1) At least one source File 2) At least one Run. 4) At least one
       * Start/End Position for each Run 5) A File and LineNum for each
       * Position.
       */

      List<File> sfs = cf.getSourceFiles();
      assertFalse("No source files in control file.", sfs == null || sfs.isEmpty());

      for (File sf : sfs) {
        assertNotNull(sf);
        assertTrue("file " + sf.getAbsolutePath() + " does not exist", sf.exists());
      }

      // for( TheoryId theory : cf.getTheories() ) {
      TheoryId theory = cf.getTheoryId();
      if (theory != null) {
        // assertNotNull( theory );
        try {
          Class.forName(theory.getQname());
        } catch (ClassNotFoundException e) {
          fail("Theory definition not found: " + theory.getQname());
        }
      }

      List<Run> runs = cf.getRuns();
      assertFalse("No runs in control file.", runs == null || runs.isEmpty());

      for (Run run : runs) {
        assertNotNull("null Run found in control file", run);
        Position sp = run.getStartPosition();
        Position ep = run.getEndPosition();
        assertNotNull("No start position for Run", sp);
        assertNotNull("No end position for Run", ep);
        checkPosition(sp);
        checkPosition(ep);
        for (Position wp : run.getWayPoints()) {
          checkPosition(wp);
        }
      }
    } catch (ControlFileException e) {
      fail(e.getMessage());
      // fail(x.toString());
    }
  }

  @Test
  public void testPProgram() {
    // Make the control file filter
    FilenameFilter filter =
        new FilenameFilter() {
          public boolean accept(File dir, String name) {
            return name.endsWith(".ctrl");
          }
        };

    TestUtils.Tester<File> tester =
        new TestUtils.Tester<File>() {
          @Override
          public void runTest(File f) {
            parseFromFile(f);
          }
        };

    TestUtils.checkDirectory(programs_location, filter, tester, false);
    TestUtils.checkDirectory(bad_programs_location, filter, tester, true);
  }
}