示例#1
0
 @Test
 public void test() throws Exception {
   InputStream is = HpackTest.class.getResourceAsStream(TEST_DIR + fileName);
   TestCase testCase = TestCase.load(is);
   testCase.testCompress();
   testCase.testDecompress();
 }
 public double computeSumAPOn(List<TestCase> testCases, RankingAlgo.Type type) {
   double apSum = 0.0;
   for (TestCase testCase : testCases) {
     apSum += computeAPOn(testCase.getRankRecords(type), testCase.getAnsRecords());
   }
   return apSum;
 }
示例#3
0
  /**
   * Makes sure the MDX runs correctly and not in native mode.
   *
   * @param rowCount Number of rows returned
   * @param mdx Query
   * @param expectedResult Expected result string
   */
  protected void checkNotNative(int rowCount, String mdx, String expectedResult) {
    getConnection().getCacheControl(null).flushSchemaCache();
    Connection con = getTestContext().withSchemaPool(false).getConnection();
    RolapNativeRegistry reg = getRegistry(con);
    reg.setListener(
        new Listener() {
          public void foundEvaluator(NativeEvent e) {
            fail("should not be executed native");
          }

          public void foundInCache(TupleEvent e) {}

          public void executingSql(TupleEvent e) {}
        });

    TestCase c = new TestCase(con, 0, rowCount, mdx);
    Result result = c.run();

    if (expectedResult != null) {
      String nonNativeResult = TestContext.toString(result);
      if (!nonNativeResult.equals(expectedResult)) {
        TestContext.assertEqualsVerbose(
            expectedResult,
            nonNativeResult,
            false,
            "Non Native implementation returned different result than " + "expected; MDX=" + mdx);
      }
    }
  }
示例#4
0
  public TestResult run() {
    for (TestCase testCase : tests) {
      testCase.run(result);
    }

    return result;
  }
  private Iterable<TestResult> pruneToDepth(List<TestResult> results, Integer depth) {
    // Prune the response to the requested depth
    // 0 - TestResult
    // 1 - TestCapability
    // 2 - TestSuite
    // 3 - TestCase
    // 4 - Entire response
    // null - Entire response
    if (depth == null || depth > 3) {
      return results;
    }
    for (TestResult result : results) {
      if (depth == 0) {
        result.getTestCapabilities().clear();
      } else {
        for (TestCapability testCapability : result.getTestCapabilities()) {
          if (depth == 1) {
            testCapability.getTestSuites().clear();
          } else {
            for (TestSuite testSuite : testCapability.getTestSuites()) {
              if (depth == 2) {
                testSuite.getTestCases().clear();
              } else { // depth == 3
                for (TestCase testCase : testSuite.getTestCases()) {
                  testCase.getTestSteps().clear();
                }
              }
            }
          }
        }
      }
    }

    return results;
  }
示例#6
0
  protected void addTest(Class<?> clazz, ITestResult result) {
    try {
      TestCase test_case =
          new TestCase(
              result.getStatus(),
              clazz.getName(),
              getMethodName(result),
              result.getStartMillis(),
              result.getEndMillis());
      switch (result.getStatus()) {
        case ITestResult.FAILURE:
        case ITestResult.SKIP:
          Throwable ex = result.getThrowable();
          if (ex != null) {
            String failure_type = ex.getClass().getName();
            String failure_msg = ex.getMessage();
            String stack_trace = printException(ex);
            test_case.setFailure(failure_type, failure_msg, stack_trace);
          } else test_case.setFailure("exception", "SKIPPED", null);
          break;
      }

      synchronized (
          this) { // handle concurrent access by different threads, if test methods are run in
        // parallel
        DataOutputStream output = tests.get(clazz);
        test_case.writeTo(output);
      }
    } catch (Exception e) {
      error(e.toString());
    }
  }
示例#7
0
 public void testNamelessTestCase() {
   TestCase t = new TestCase() {};
   try {
     t.run();
     fail();
   } catch (AssertionFailedError e) {
   }
 }
示例#8
0
 protected void doRun(TestCase testCase) throws Exception {
   if (testCase.isIgnored()) {
     logWarning(Text.valueOf("Ignore ").plus(testCase.getName()));
     return;
   }
   logMessage("test", Text.valueOf(testCase.getName()));
   super.doRun(testCase);
 }
示例#9
0
 public void initTestCaseInfo() {
   for (TestExpect ep : expectedList) {
     TestCase testCase = new TestCase();
     testCase.setBussinessDesp(ep.getBussinessDesp());
     testCase.setResult(ep.getResult());
     testCase.setRemark(ep.getExpect() + "\n" + ep.getActual());
     testResult.getItem().add(testCase);
   }
 }
示例#10
0
 /** Returns execution details as sonar-conform XML */
 public String getDetails() {
   StringBuilder details = new StringBuilder();
   details.append("<tests-details>");
   for (TestCase tc : testCases) {
     details.append(tc.getDetails());
   }
   details.append("</tests-details>");
   return details.toString();
 }
 @Test
 public void shouldInjectActivityIntoTestCaseMarkedAsSubject()
     throws NoSuchFieldException, IllegalAccessException {
   when(testCase.getTestSubjectClassType()).thenReturn(Activity.class);
   when(testCase.getTestSubjectField()).thenReturn(getSampleField());
   when(testCase.getTestCaseInstance()).thenReturn(testCaseInstance);
   when(injector.getInstance(Activity.class)).thenReturn(activity);
   testFieldInjector.setupTestCase();
   verify(reflectionUtils).forceSetValueOnField(getSampleField(), testCaseInstance, activity);
 }
 public static boolean unequalSizeCheck(Test test) {
   int ins = test.getNet().getInputLayer().size();
   int outs = test.getNet().getOutputLayer().size();
   for (TestCase tc : test.getCases()) {
     if ((tc.getInputs().length != ins) || (tc.getOutputs().length != outs)) {
       return false;
     }
   }
   return true;
 }
  public void run(CommandExecutor executor) {

    TestCase[] testcases = {
      new TestCase(1, "testcaseMethod1"),
      new TestCase(2, "testcaseMethod2"),
      new TestCase(3, "testcaseMethod3"),
      new TestCase(4, "testcaseMethod4"),
    };

    // Lock compilation makes all compiles stay in queue or compile thread before completion
    WB.lockCompilation();

    // Enqueue one test method for each available level
    int[] complevels = CompilerUtils.getAvailableCompilationLevels();
    for (int level : complevels) {
      TestCase testcase = testcases[level - 1];

      boolean added = WB.enqueueMethodForCompilation(testcase.method, testcase.level);
      // Set results to false for those methods we must to find
      // We will also assert if we find any test method we don't expect
      Assert.assertEquals(added, WB.isMethodQueuedForCompilation(testcase.method));
      testcase.check = false;
    }

    // Get output from dcmd (diagnostic command)
    OutputAnalyzer output = executor.execute("Compiler.queue");
    Iterator<String> lines = output.asLines().iterator();

    // Loop over output set result for all found methods
    while (lines.hasNext()) {
      String str = lines.next();
      // Fast check for common part of method name
      if (str.contains("testcaseMethod")) {
        for (TestCase testcase : testcases) {
          if (str.contains(testcase.methodName)) {
            Assert.assertFalse(testcase.check, "Must not be found or already found.");
            testcase.check = true;
          }
        }
      }
    }

    for (TestCase testcase : testcases) {
      if (!testcase.check) {
        // If this method wasn't found it must have been removed by policy,
        // verify that it is now removed from the queue
        Assert.assertFalse(
            WB.isMethodQueuedForCompilation(testcase.method), "Must be found or not in queue");
      }
      // Otherwise all good.
    }

    // Enable compilations again
    WB.unlockCompilation();
  }
示例#14
0
  private void doStoreTestNow() throws HoneycombTestException {
    TestCase self = createTestCase("setupStore", "filesize=" + getFilesize());
    self.addTag(Tag.SMOKE);
    self.addTag(Tag.REGRESSION);
    self.addTag(Tag.POSITIVE);
    self.addTag(Tag.SMOKE);
    self.addTag(HoneycombTag.STOREDATA);
    self.addTag(HoneycombTag.JAVA_API);
    self.addTag(HoneycombTag.EMULATOR);

    if (self.excludeCase()) return;

    storeResult = store(getFilesize());

    // successful result will only be posted if we didn't throw
    self.testPassed(
        "Stored file of size "
            + getFilesize()
            + " as oid "
            + storeResult.mdoid
            + " @ "
            + (storeResult.filesize * 1000 / storeResult.time)
            + " bytes/sec");
    setupOK = true;
  }
示例#15
0
 private TestCase getTestCase(Access access1, Access access2) {
   try {
     return TestCase.valueOf(access1.toString() + "_" + access2.toString());
   } catch (Exception e1) {
     try {
       return TestCase.valueOf(access2.toString() + "_" + access1.toString());
     } catch (Exception e2) {
       return null;
     }
   }
 }
示例#16
0
  @Test
  public void testSelfSimilarity() {

    TestCase test = new DefaultTestCase();

    PrimitiveStatement<?> aInt = new IntPrimitiveStatement(test, 42);
    test.addStatement(aInt);

    double score = DiversityObserver.getNeedlemanWunschScore(test, test);
    Assert.assertTrue(score > 0);
  }
示例#17
0
 @Override
 protected void tearDown() throws Exception {
   super.tearDown();
   framework.stop();
   IO.delete(tmp);
   Main.stop();
   IO.delete(IO.getFile("generated/cache"));
   IO.delete(IO.getFile("generated/storage"));
   framework.waitForStop(100000);
   super.tearDown();
 }
示例#18
0
 protected void runTestProfiled() throws Throwable {
   // Warmup run, notably to trigger all needed classloading.
   super.runTest();
   long t0 = System.nanoTime();
   try {
     super.runTest();
   } finally {
     long elapsedMillis = millisElapsedSince(t0);
     if (elapsedMillis >= profileThreshold)
       System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
   }
 }
示例#19
0
 /**
  * Adds the given test case to this testsuite maintaining the internal statistics
  *
  * @param tc the test case to add
  */
 public void addTestCase(TestCase tc) {
   if (tc.isSkipped()) {
     skipped++;
   } else if (tc.isFailure()) {
     failures++;
   } else if (tc.isError()) {
     errors++;
   }
   tests++;
   time += tc.getTime();
   testCases.add(tc);
 }
 @Test
 public void shouldInjectFragmentIntoTestCaseMarkedAsSubject()
     throws NoSuchFieldException, IllegalAccessException {
   when(testCase.getTestSubjectClassType()).thenReturn(RoboFragment.class);
   when(testCase.getTestSubjectField()).thenReturn(getSampleField());
   when(testCase.getTestCaseInstance()).thenReturn(testCaseInstance);
   when(reflectionUtils.classIsOfAssignableForm(RoboFragment.class, RoboFragment.class))
       .thenReturn(true);
   when(reflectionUtils.createObjectProxy(RoboFragment.class, testFieldInjector))
       .thenReturn(fragment);
   testFieldInjector.setupTestCase();
   verify(reflectionUtils).forceSetValueOnField(getSampleField(), testCaseInstance, fragment);
 }
 @Test
 public void shouldSetMocksIntoTestCase() throws NoSuchFieldException, IllegalAccessException {
   Object mockOne = mock(Object.class);
   Object mockTwo = mock(Object.class);
   when(testCase.getTestCaseInstance()).thenReturn(testCaseInstance);
   when(testCase.getFieldsMarkedWithMock())
       .thenReturn(Lists.newArrayList(getSampleField(), getSecondSampleField()));
   when(injector.getInstance(getSampleField().getType())).thenReturn(mockOne);
   when(injector.getInstance(getSecondSampleField().getType())).thenReturn(mockTwo);
   testFieldInjector.setupTestCase();
   verify(reflectionUtils).forceSetValueOnField(getSampleField(), testCaseInstance, mockOne);
   verify(reflectionUtils).forceSetValueOnField(getSecondSampleField(), testCaseInstance, mockTwo);
 }
 public static void main(String[] args) {
   try {
     // to init Utils before call SecurityManager
     Class.forName(Utils.class.getName(), true, Utils.class.getClassLoader());
   } catch (ClassNotFoundException e) {
     throw new Error("[TEST BUG]: jdk.test.lib.Utils not found", e);
   }
   try {
     TestCase mode = TestCase.valueOf(args[0]);
     mode.run();
   } catch (IllegalArgumentException e) {
     throw new Error("[TEST BUG]: Unknown mode " + args[0], e);
   }
 }
示例#23
0
 /**
  * Launch the test.
  *
  * @param args the command line arguments
  * @generatedBy CodePro at 18/10/13 19:08
  */
 public static void main(String[] args) {
   if (args.length == 0) {
     // Run all of the tests
     junit.textui.TestRunner.run(EC2WorkerTest.class);
   } else {
     // Run only the named tests
     TestSuite suite = new TestSuite("Selected tests");
     for (int i = 0; i < args.length; i++) {
       TestCase test = new EC2WorkerTest();
       test.setName(args[i]);
       suite.addTest(test);
     }
     junit.textui.TestRunner.run(suite);
   }
 }
示例#24
0
 public void test(TestCase testCase) {
   System.out.println(testCase.name());
   ConstantPool cp = testCase.getConstantPool();
   String cpStringRep = cp.toString();
   String cpClassSimpleName = CompilerToVMHelper.HotSpotConstantPoolClass().getSimpleName();
   if (!cpStringRep.contains(cpClassSimpleName) || !cpStringRep.contains(TEST_CLASS.getName())) {
     String msg =
         String.format(
             "%s : "
                 + " Constant pool is not valid."
                 + " String representation should contain \"%s\" and \"%s\"",
             testCase.name(), cpClassSimpleName, TEST_CLASS.getName());
     throw new AssertionError(msg);
   }
 }
示例#25
0
  @Test
  public void testBasicSimilarity() {

    TestCase test1 = new DefaultTestCase();
    TestCase test2 = new DefaultTestCase();

    PrimitiveStatement<?> aInt = new IntPrimitiveStatement(test1, 42);
    test1.addStatement(aInt);

    PrimitiveStatement<?> bInt = new IntPrimitiveStatement(test2, 42);
    test2.addStatement(bInt);

    double score = DiversityObserver.getNeedlemanWunschScore(test1, test2);
    Assert.assertTrue(score > 0);
  }
示例#26
0
 @Override
 protected void tearDown() throws Exception {
   framework.stop();
   framework.waitForStop(10000);
   IO.delete(tmp);
   super.tearDown();
 }
示例#27
0
  @Test
  public void testSingleStorable() {
    class TestCase implements Storable {
      @Store private int value = 0;
    }
    TestCase test = new TestCase();
    test.value = 256;

    Data data = new Data();
    test.save(data);

    test = new TestCase();
    test.load(data);

    assertThat(test.value).isEqualTo(256);
  }
 /** Intercept test case invocation and delegate it to a remote server. */
 public void runBare() throws Throwable {
   if (shouldRunTestOnServer()) {
     runBareClient();
   } else {
     super.runBare();
   }
 }
  protected void tearDown() throws Exception {
    _styleSheet = null;
    _hWPFDocFixture.tearDown();

    _hWPFDocFixture = null;
    super.tearDown();
  }
示例#30
0
  @Override
  protected void setUp() throws Exception {
    tmp = IO.getFile("generated/tmp");
    tmp.mkdirs();

    configuration = new HashMap<String, Object>();
    configuration.put(
        Constants.FRAMEWORK_STORAGE_CLEAN, Constants.FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT);
    configuration.put(Constants.FRAMEWORK_STORAGE, new File(tmp, "fwstorage").getAbsolutePath());
    configuration.put(
        Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, "org.osgi.framework.launch;version=1.4");
    framework = new org.apache.felix.framework.FrameworkFactory().newFramework(configuration);
    framework.init();
    framework.start();
    BundleContext context = framework.getBundleContext();

    String[] bundles = {
      "../cnf/repo/osgi.cmpn/osgi.cmpn-4.3.1.jar", "testdata/slf4j-simple-1.7.12.jar",
      "testdata/slf4j-api-1.7.12.jar", "testdata/org.apache.aries.util-1.1.0.jar",
      "testdata/org.apache.aries.jmx-1.1.1.jar", "generated/biz.aQute.remote.test.jmx.jar"
    };

    for (String bundle : bundles) {
      String location = "reference:" + IO.getFile(bundle).toURI().toString();
      Bundle b = context.installBundle(location);
      if (!bundle.contains("slf4j-simple")) {
        b.start();
      }
    }

    super.setUp();
  }