Example #1
0
  /** Path & edge are the same, directions are reverse, neg. to pos. */
  @Test
  public void testPathStateConvert7() {

    final Path startPath =
        TestUtils.makeTmpPath(
            graph,
            true,
            new Coordinate(20, -10),
            new Coordinate(10, -10),
            new Coordinate(10, 0),
            new Coordinate(0, 0));
    final Matrix covar =
        MatrixFactory.getDefault()
            .copyArray(new double[][] {new double[] {126.56, 8.44}, new double[] {8.44, 0.56}});
    final MultivariateGaussian startBelief =
        new AdjMultivariateGaussian(VectorFactory.getDefault().createVector2D(-2.5d, 1d), covar);
    final PathStateDistribution currentBelief = new PathStateDistribution(startPath, startBelief);

    final Path newPath =
        TestUtils.makeTmpPath(graph, false, new Coordinate(10, 0), new Coordinate(0, 0));

    final PathStateDistribution result = currentBelief.convertToPath(newPath);

    AssertJUnit.assertEquals("distance", 7.5d, result.getMean().getElement(0), 0d);
    AssertJUnit.assertEquals("velocity", 1d, result.getMean().getElement(1), 0d);
  }
Example #2
0
  @Test
  public void testPathStateConvert2() {
    final Path startPath =
        TestUtils.makeTmpPath(graph, false, new Coordinate(0, 0), new Coordinate(10, 0));

    final Matrix covar =
        MatrixFactory.getDefault()
            .copyArray(new double[][] {new double[] {126.56, 8.44}, new double[] {8.44, 0.56}});
    final MultivariateGaussian startBelief =
        new AdjMultivariateGaussian(VectorFactory.getDenseDefault().createVector2D(0d, 1d), covar);
    final PathStateDistribution currentBelief = new PathStateDistribution(startPath, startBelief);

    final Vector groundLoc =
        MotionStateEstimatorPredictor.getOg()
            .times(currentBelief.getGroundDistribution().getMean());
    AssertJUnit.assertEquals("initial state x", 0d, groundLoc.getElement(0), 0d);
    AssertJUnit.assertEquals("initial state y", 0d, groundLoc.getElement(1), 0d);

    final Path newPath =
        TestUtils.makeTmpPath(
            graph,
            true,
            new Coordinate(20, -10),
            new Coordinate(10, -10),
            new Coordinate(10, 0),
            new Coordinate(0, 0));

    final PathStateDistribution result = currentBelief.convertToPath(newPath);

    AssertJUnit.assertEquals("distance", -0d, result.getMean().getElement(0), 0d);
    AssertJUnit.assertEquals("velocity", -1d, result.getMean().getElement(1), 0d);
  }
  @Test
  public void test110ChangeModifyObject() throws Exception {
    final String TEST_NAME = "test110ChangeModifyObject";
    TestUtil.displayTestTile(this, TEST_NAME);

    OperationResult result = new OperationResult(this.getClass().getName() + "." + TEST_NAME);

    Collection<ResourceAttribute<?>> identifiers = addSampleResourceObject("john", "John", "Smith");

    Set<Operation> changes = new HashSet<Operation>();

    changes.add(createAddAttributeChange("employeeNumber", "123123123"));
    changes.add(createReplaceAttributeChange("sn", "Smith007"));
    changes.add(createAddAttributeChange("street", "Wall Street"));
    changes.add(createDeleteAttributeChange("givenName", "John"));

    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(
            ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME);

    cc.modifyObject(accountDefinition, identifiers, changes, result);

    ResourceObjectIdentification identification =
        new ResourceObjectIdentification(accountDefinition, identifiers);
    PrismObject<ShadowType> shadow = cc.fetchObject(ShadowType.class, identification, null, result);
    ResourceAttributeContainer resObj = ShadowUtil.getAttributesContainer(shadow);

    AssertJUnit.assertNull(
        resObj.findAttribute(
            new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "givenName")));

    String addedEmployeeNumber =
        resObj
            .findAttribute(
                new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "employeeNumber"))
            .getValue(String.class)
            .getValue();
    String changedSn =
        resObj
            .findAttribute(new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "sn"))
            .getValues(String.class)
            .iterator()
            .next()
            .getValue();
    String addedStreet =
        resObj
            .findAttribute(new QName(ResourceTypeUtil.getResourceNamespace(resourceType), "street"))
            .getValues(String.class)
            .iterator()
            .next()
            .getValue();

    System.out.println("changed employee number: " + addedEmployeeNumber);
    System.out.println("changed sn: " + changedSn);
    System.out.println("added street: " + addedStreet);

    AssertJUnit.assertEquals("123123123", addedEmployeeNumber);
    AssertJUnit.assertEquals("Smith007", changedSn);
    AssertJUnit.assertEquals("Wall Street", addedStreet);
  }
  /**
   * Simple call to connector test() method.
   *
   * @throws Exception
   */
  @Test
  public void test310TestConnectionNegative() throws Exception {
    final String TEST_NAME = "test310TestConnectionNegative";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN

    OperationResult result = new OperationResult(TEST_NAME);

    ConnectorInstance badConnector =
        factory.createConnectorInstance(
            connectorType,
            ResourceTypeUtil.getResourceNamespace(badResourceType),
            "test connector");
    badConnector.configure(
        badResourceType.getConnectorConfiguration().asPrismContainerValue(), result);

    // WHEN

    badConnector.test(result);

    // THEN
    result.computeStatus("test failed");
    display("Test result (FAILURE EXPECTED)", result);
    AssertJUnit.assertNotNull(result);
    OperationResult connectorConnectionResult = result.getSubresults().get(1);
    AssertJUnit.assertNotNull(connectorConnectionResult);
    System.out.println(
        "Test \"connector connection\" result: "
            + connectorConnectionResult
            + " (FAILURE EXPECTED)");
    AssertJUnit.assertTrue(
        "Unexpected success of bad connector test", !connectorConnectionResult.isSuccess());
    AssertJUnit.assertTrue(!result.isSuccess());
  }
 /**
  * Test if all providers returns valid meta data.
  *
  * @see javax.money.convert.ProviderContext
  */
 @Test(
     description =
         "4.3.1 Test if all ExchangeRateProvider instances returns valid ProviderContext.")
 @SpecAssertion(id = "431-A3", section = "4.3.1")
 public void testProviderMetadata() {
   for (String providerName : MonetaryConversions.getConversionProviderNames()) {
     ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerName);
     AssertJUnit.assertNotNull("Provider mot accessible: " + providerName, prov);
     ProviderContext ctx = prov.getContext();
     AssertJUnit.assertNotNull(
         "ExchangeProvider must return a valid ProviderContext, but returned null: "
             + providerName,
         ctx);
     AssertJUnit.assertEquals(
         "ExchangeProvider's ProviderContext returns invalid name: " + providerName,
         providerName,
         ctx.getProviderName());
     AssertJUnit.assertNotNull(
         "ExchangeProvider's ProviderContext declares invalid RateTypes to be returned (null): "
             + providerName,
         ctx.getRateTypes());
     AssertJUnit.assertFalse(
         "ExchangeProvider's ProviderContext declares empty RateTypes to be returned: "
             + providerName,
         ctx.getRateTypes().isEmpty());
   }
 }
 public void multipleFlushTest() throws IOException {
   final String filename = "longFile.writtenInMultipleFlushes";
   final int bufferSize = 300;
   Cache cache = cacheManager.getCache();
   cache.clear();
   Directory dir =
       DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEXNAME)
           .chunkSize(13)
           .create();
   byte[] manyBytes = fillBytes(bufferSize);
   IndexOutput indexOutput = dir.createOutput(filename);
   for (int i = 0; i < 10; i++) {
     indexOutput.writeBytes(manyBytes, bufferSize);
     indexOutput.flush();
   }
   indexOutput.close();
   IndexInput input = dir.openInput(filename);
   final int finalSize = (10 * bufferSize);
   AssertJUnit.assertEquals(finalSize, input.length());
   final byte[] resultingBuffer = new byte[finalSize];
   input.readBytes(resultingBuffer, 0, finalSize);
   int index = 0;
   for (int i = 0; i < 10; i++) {
     for (int j = 0; j < bufferSize; j++)
       AssertJUnit.assertEquals(resultingBuffer[index++], manyBytes[j]);
   }
 }
Example #7
0
  public void testAdded() throws Exception {
    prepareTestData();
    queryParser = createQueryParser("blurb");

    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    List<Object> found = cacheQuery.list();

    AssertJUnit.assertEquals(2, found.size());
    assert found.contains(person2);
    assert found.contains(person3);
    assert !found.contains(person4) : "This should not contain object person4";

    person4 = new Person();
    person4.setName("Mighty Goat");
    person4.setBlurb("Also eats grass");

    cache1.put("mighty", person4);

    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    found = cacheQuery.list();

    AssertJUnit.assertEquals(3, found.size());
    assert found.contains(person2);
    assert found.contains(person3);
    assert found.contains(person4) : "This should now contain object person4";
  }
 /**
  * Access and test different Currency Conversions for the provider in place.
  *
  * <p>Test TCK providers, but also test implementation providers. Doing the ladder it is not
  * possible to test the rates quality, just that rates are returned if necessary.
  */
 @Test(
     description =
         "4.3.1 Access Conversion by query to term currency XXX for all providers that support according "
             + "conversion, if"
             + "available a non-null CurrencyConversion must be provided.")
 @SpecAssertion(id = "431-A2", section = "4.3.1")
 public void testConversionsAreAvailableWithQuery() {
   for (String providerName : MonetaryConversions.getConversionProviderNames()) {
     ConversionQuery query =
         ConversionQueryBuilder.of().setTermCurrency("XXX").setProviderNames(providerName).build();
     try {
       if (MonetaryConversions.isConversionAvailable(query)) {
         CurrencyConversion conv = MonetaryConversions.getConversion(query);
         AssertJUnit.assertNotNull(
             "CurrencyConversion returned from MonetaryConversions.getConversion(ConversionQuery) must"
                 + " "
                 + "never be null: "
                 + providerName,
             conv);
         AssertJUnit.assertTrue(
             "CurrencyConversion is not flagged as available though it was returned from "
                 + "MonetaryConversions.getConversion(ConversionQuery): "
                 + providerName,
             MonetaryConversions.isConversionAvailable(query));
       }
     } catch (MonetaryException e) {
       // OK, possible!
       AssertJUnit.assertFalse(
           "CurrencyConversion is not flagged as not available, though it was not returned from "
               + "MonetaryConversions.getConversion(ConversionQuery): "
               + providerName,
           MonetaryConversions.isConversionAvailable(query));
     }
   }
 }
  @Test
  public void testAddGroupAdminRoleToAuthorizationGroup() throws Exception {
    String code = AUTH_GROUP_ID;
    AuthorizationGroupPE authGroup = createAuthGroupInDB(code);
    AssertJUnit.assertEquals(
        0,
        daoFactory
            .getRoleAssignmentDAO()
            .listRoleAssignmentsByAuthorizationGroup(authGroup)
            .size());

    GroupPE group = daoFactory.getGroupDAO().listGroups().get(0);
    RoleAssignmentPE roleAssignment = new RoleAssignmentPE();
    roleAssignment.setRole(RoleCode.ADMIN);
    roleAssignment.setGroup(group);
    roleAssignment.setRegistrator(getSystemPerson());

    authGroup.addRoleAssignment(roleAssignment);
    AssertJUnit.assertEquals(
        1,
        daoFactory
            .getRoleAssignmentDAO()
            .listRoleAssignmentsByAuthorizationGroup(authGroup)
            .size());
  }
 @Test
 public void select() {
   HTMLEditor htmlEditorNode =
       (HTMLEditor) getPrimaryStage().getScene().getRoot().lookup(".html-editor");
   Platform.runLater(
       () -> {
         htmlEditor.marathon_select("This html editor test");
       });
   try {
     new Wait("Waiting for html text to be set.") {
       @Override
       public boolean until() {
         String htmlText = htmlEditorNode.getHtmlText();
         return htmlText.equals(
             "<html dir=\"ltr\"><head></head><body contenteditable=\"true\">This html editor test</body></html>");
       }
     };
   } catch (Throwable t) {
   }
   AssertJUnit.assertEquals(
       "<html dir=\"ltr\"><head></head><body contenteditable=\"true\">This html editor test</body></html>",
       htmlEditor.getText());
   AssertJUnit.assertEquals(
       "<html dir=\"ltr\"><head></head><body contenteditable=\"true\">This html editor test</body></html>",
       htmlEditorNode.getHtmlText());
 }
  public void testBasicTargetRemoteDistributedCallable() throws Exception {
    long taskTimeout = TimeUnit.SECONDS.toMillis(15);
    EmbeddedCacheManager cacheManager1 = manager(0);
    final EmbeddedCacheManager cacheManager2 = manager(1);

    Cache<Object, Object> cache1 = cacheManager1.getCache();
    Cache<Object, Object> cache2 = cacheManager2.getCache();
    DistributedExecutorService des = null;

    try {
      des = new DefaultExecutorService(cache1);
      Address target = cache2.getAdvancedCache().getRpcManager().getAddress();

      DistributedTaskBuilder<Integer> builder =
          des.createDistributedTaskBuilder(new SimpleCallable())
              .failoverPolicy(DefaultExecutorService.RANDOM_NODE_FAILOVER)
              .timeout(taskTimeout, TimeUnit.MILLISECONDS);

      Future<Integer> future = des.submit(target, builder.build());
      AssertJUnit.assertEquals((Integer) 1, future.get());
    } catch (Exception ex) {
      AssertJUnit.fail("Task did not failover properly " + ex);
    } finally {
      des.shutdown();
    }
  }
 /**
  * Access and test different Currency Conversions for the provider in place.
  *
  * <p>Test TCK providers, but also test implementation providers. Doing the ladder it is not
  * possible to test the rates quality, just that rates are returned if necessary.
  */
 @Test(
     description =
         "4.3.1 Access Conversion to term currency code XXX for all providers that support according "
             + "conversion, if"
             + "available a non-null CurrencyConversion must be provided.")
 @SpecAssertion(id = "431-A2", section = "4.3.1")
 public void testConversionsAreAvailable() {
   for (String providerName : MonetaryConversions.getConversionProviderNames()) {
     try {
       if (MonetaryConversions.isConversionAvailable("XXX", providerName)) {
         CurrencyConversion conv = MonetaryConversions.getConversion("XXX", providerName);
         AssertJUnit.assertNotNull(
             "CurrencyConversion returned from MonetaryConversions.getConversion(String, "
                 + "String...) should never be null: "
                 + providerName,
             conv);
         AssertJUnit.assertTrue(
             "CurrencyConversion is not flagged as available, "
                 + "though it was returned from MonetaryConversions.getConversion"
                 + "(String,"
                 + " String...): "
                 + providerName,
             MonetaryConversions.isConversionAvailable("XXX", providerName));
       }
     } catch (MonetaryException e) {
       AssertJUnit.assertFalse(
           "CurrencyConversion is not flagged as NOT available, though it is not accessible from "
               + "MonetaryConversions.getConversion(String, String...): "
               + providerName,
           MonetaryConversions.isConversionAvailable("XXX", providerName));
     }
   }
 }
 /**
  * Test if all providers returns valid meta data.
  *
  * @see javax.money.convert.ProviderContext
  */
 @Test(
     description =
         "4.3.1 Test if all CurrencyConversion instances returns valid ConversionContext, accessed by "
             + "ConversionQuery/CurrencyUnit.")
 @SpecAssertion(id = "431-A3", section = "4.3.1")
 public void testProviderMetadata3WithContext() {
   for (String providerName : MonetaryConversions.getConversionProviderNames()) {
     ConversionQuery query =
         ConversionQueryBuilder.of()
             .setTermCurrency(Monetary.getCurrency("XXX"))
             .setProviderName(providerName)
             .build();
     if (MonetaryConversions.isConversionAvailable(query)) {
       CurrencyConversion conv = MonetaryConversions.getConversion(query);
       ConversionContext ctx = conv.getContext();
       AssertJUnit.assertNotNull(
           "ExchangeProvider must return a valid ProviderContext, but returned null: "
               + providerName,
           ctx);
       AssertJUnit.assertEquals(
           "ExchangeProvider's ProviderContext returns invalid name: " + providerName,
           providerName,
           ctx.getProviderName());
       AssertJUnit.assertNotNull(
           "ExchangeProvider's ProviderContext declares invalid RateTypes to be returned (null): "
               + providerName,
           ctx.getRateType());
     }
   }
 }
 /**
  * Test if all providers returns valid meta data.
  *
  * @see javax.money.convert.ProviderContext
  */
 @Test(
     description =
         "4.3.1 Test if all CurrencyConversion instances returns valid ConversionContext, accessed by "
             + "currency code.")
 @SpecAssertion(id = "431-A3", section = "4.3.1")
 public void testProviderMetadata2() {
   for (String providerName : MonetaryConversions.getConversionProviderNames()) {
     if (MonetaryConversions.isConversionAvailable("XXX", providerName)) {
       CurrencyConversion conv = MonetaryConversions.getConversion("XXX", providerName);
       ConversionContext ctx = conv.getContext();
       AssertJUnit.assertNotNull(
           "ExchangeProvider must return a valid ProviderContext, but returned null: "
               + providerName,
           ctx);
       AssertJUnit.assertEquals(
           "ExchangeProvider's ProviderContext returns invalid name: " + providerName,
           providerName,
           ctx.getProviderName());
       AssertJUnit.assertNotNull(
           "ExchangeProvider's ProviderContext declares invalid RateTypes to be returned (null): "
               + providerName,
           ctx.getRateType());
     }
   }
 }
 private void testOn(Directory dir, int writeSize, int readSize, Cache cache) throws IOException {
   if (cache != null)
     cache
         .clear(); // needed to make sure no chunks are left over in case of Infinispan
                   // implementation
   final String filename = "chunkTest";
   IndexOutput indexOutput = dir.createOutput(filename);
   byte[] toWrite = fillBytes(writeSize);
   indexOutput.writeBytes(toWrite, writeSize);
   indexOutput.close();
   if (cache != null) {
     AssertJUnit.assertEquals(
         writeSize,
         DirectoryIntegrityCheck.deepCountFileSize(new FileCacheKey(INDEXNAME, filename), cache));
   }
   AssertJUnit.assertEquals(writeSize, indexOutput.length());
   byte[] results = new byte[readSize];
   IndexInput openInput = dir.openInput(filename);
   try {
     openInput.readBytes(results, 0, readSize);
     for (int i = 0; i < writeSize && i < readSize; i++) {
       AssertJUnit.assertEquals(results[i], toWrite[i]);
     }
     if (readSize > writeSize)
       AssertJUnit.fail("should have thrown an IOException for reading past EOF");
   } catch (IOException ioe) {
     if (readSize <= writeSize)
       AssertJUnit.fail("should not have thrown an IOException" + ioe.getMessage());
   }
 }
Example #16
0
  @Test
  public void test() throws SQLException {

    LOGGER.info("Method test start");
    Throwable got = null;
    try {
      tf0();
    } catch (final Throwable throwable) {
      got = throwable;
    } finally {
      final DataSource dataSource = DataSource.class.cast(context.getBean("dataSource"));
      final Connection connection = dataSource.getConnection();
      final Map<String, Object> resultMap = new HashMap<String, Object>();
      try {
        JDBCHelper.executeQuery("select name from test", connection, resultMap);
      } finally {
        if (connection != null) {
          connection.close();
        }
      }
      AssertJUnit.assertTrue(resultMap.isEmpty());
    }
    AssertJUnit.assertNotNull(got);
    LOGGER.info("Method test end");
  }
Example #17
0
 @Override
 public void readBytes(byte[] b, int offset, int len) throws IOException {
   final long remainingFileSize = TEST_SIZE - position;
   final long expectedReadSize = Math.min(remainingFileSize, AUTO_BUFFER);
   AssertJUnit.assertEquals(expectedReadSize, b.length);
   AssertJUnit.assertEquals(0, offset);
   AssertJUnit.assertEquals(expectedReadSize, len);
 }
Example #18
0
 /** @throws Exception On test failure. */
 @AfterClass(groups = {"cache"})
 public void clear() throws Exception {
   fillCache();
   AssertJUnit.assertEquals(5, cache.size());
   cache.clear();
   AssertJUnit.assertEquals(0, cache.size());
   cache.close();
 }
 public void getLeftRightComponents() throws Throwable {
   driver = new JavaDriver();
   WebElement splitPaneLeft = driver.findElement(By.cssSelector("split-pane::left"));
   splitPaneLeft.findElement(By.cssSelector("list"));
   WebElement splitPaneTop = driver.findElement(By.cssSelector("split-pane::top"));
   AssertJUnit.assertEquals(splitPaneTop, splitPaneLeft);
   WebElement splitPaneRight = driver.findElement(By.cssSelector("split-pane::right"));
   WebElement splitPaneBottom = driver.findElement(By.cssSelector("split-pane::bottom"));
   AssertJUnit.assertEquals(splitPaneBottom, splitPaneRight);
 }
 @Test
 public void testFindFederalstatesFromCountryCountriesString() {
   Countries germany = countriesService.find("DE");
   List<Federalstates> federalstates =
       federalstatesService.findFederalstatesFromCountry(germany, "Hamburg");
   AssertJUnit.assertEquals(1, federalstates.size());
   Federalstates federalstate = federalstatesService.findFederalstate(germany, "Hamburg");
   AssertJUnit.assertNotNull(federalstate);
   AssertJUnit.assertEquals("Hamburg", federalstate.getName());
 }
 /** Verifies a file is divided in N chunks */
 private void assertHasNChunks(
     int expectedChunks, Cache cache, String index, String fileName, int bufferSize) {
   int i = 0;
   for (; i < expectedChunks; i++) {
     ChunkCacheKey key = new ChunkCacheKey(index, fileName, i, bufferSize);
     AssertJUnit.assertTrue("should contain key " + key, cache.containsKey(key));
   }
   ChunkCacheKey key = new ChunkCacheKey(index, fileName, i, bufferSize);
   AssertJUnit.assertFalse("should NOT contain key " + key, cache.containsKey(key));
 }
  /**
   * Test fetching and translating resource schema.
   *
   * @throws Exception
   */
  @Test
  public void test400FetchResourceSchema() throws Exception {
    final String TEST_NAME = "test400FetchResourceSchema";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN

    // WHEN

    // The schema was fetched during test init. Now just check if it was OK.

    // THEN

    AssertJUnit.assertNotNull(resourceSchema);

    System.out.println(resourceSchema.debugDump());

    Document xsdSchema = resourceSchema.serializeToXsd();

    System.out.println(
        "-------------------------------------------------------------------------------------");
    System.out.println(DOMUtil.printDom(xsdSchema));
    System.out.println(
        "-------------------------------------------------------------------------------------");

    ObjectClassComplexTypeDefinition accountDefinition =
        resourceSchema.findObjectClassDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.OBJECT_CLASS_INETORGPERSON_NAME));
    AssertJUnit.assertNotNull(accountDefinition);

    AssertJUnit.assertFalse(
        "No identifiers for account object class ", accountDefinition.getIdentifiers().isEmpty());

    PrismPropertyDefinition uidDefinition =
        accountDefinition.findAttributeDefinition(
            new QName(
                ResourceTypeUtil.getResourceNamespace(resourceType),
                ProvisioningTestUtil.RESOURCE_OPENDJ_PRIMARY_IDENTIFIER_LOCAL_NAME));
    AssertJUnit.assertNotNull(uidDefinition);

    for (Definition def : resourceSchema.getDefinitions()) {
      if (def instanceof ResourceAttributeContainerDefinition) {
        ResourceAttributeContainerDefinition rdef = (ResourceAttributeContainerDefinition) def;
        assertNotEmpty("No type name in object class", rdef.getTypeName());
        assertNotEmpty(
            "No native object class for " + rdef.getTypeName(), rdef.getNativeObjectClass());

        // This is maybe not that important, but just for a sake of
        // completeness
        assertNotEmpty("No name for " + rdef.getTypeName(), rdef.getName());
      }
    }
  }
 /**
  * Test method for {@link
  * edu.psu.iam.cpr.core.database.tables.validate.ValidateUserComment#validateGetUserCommentsParameters(Database,
  * long, java.lang.String)}.
  *
  * @throws Exception
  * @throws Exception
  */
 @Test
 public final void testValidateUserCommentParameters37() throws Exception {
   openDbConnection();
   UserCommentTable userCommentTable =
       ValidateUserComment.validateGetUserCommentsParameters(
           db, 100000, "cpruser", "USER_COMMENT_MISUSE", "Y", null);
   AssertJUnit.assertTrue(userCommentTable.isReturnHistoryFlag());
   AssertJUnit.assertEquals(
       userCommentTable.getUserCommentType(), UserCommentType.USER_COMMENT_MISUSE);
   db.closeSession();
 }
 public void loggingWorks() {
   LoggingPreferences prefs = new LoggingPreferences();
   prefs.enable(LogType.DRIVER, Level.INFO);
   DesiredCapabilities caps = JavaDriver.defaultCapabilities();
   caps.setCapability(CapabilityType.LOGGING_PREFS, prefs);
   driver = new JavaDriver(caps, caps);
   LogEntries logEntries = driver.manage().logs().get(LogType.DRIVER);
   List<LogEntry> all = logEntries.getAll();
   AssertJUnit.assertEquals(2, all.size());
   AssertJUnit.assertTrue(all.get(0).getMessage().contains("A new session created. sessionID = "));
 }
 /** Access the conversion using the default conversion chain. */
 @Test(description = "4.3.1 Access and test conversion using the default provider chain.")
 @SpecAssertion(id = "431-A5", section = "4.3.1")
 public void testDefaultConversion() {
   ConversionQuery query =
       ConversionQueryBuilder.of().setTermCurrency(Monetary.getCurrency("USD")).build();
   CurrencyConversion conv = MonetaryConversions.getConversion(query);
   AssertJUnit.assertNotNull("No default CurrencyConversion returned for USD.", conv);
   query = ConversionQueryBuilder.of().setTermCurrency(Monetary.getCurrency("EUR")).build();
   conv = MonetaryConversions.getConversion(query);
   AssertJUnit.assertNotNull("No default CurrencyConversion returned for EUR.", conv);
 }
 /** @throws Exception On test failure. */
 @Test(groups = {"passtest"})
 public void resolveMessage() throws Exception {
   final Rule rule = new RepeatCharacterRegexRule();
   final RuleResult result = rule.validate(new PasswordData(new Password("p4&&&&&#n65")));
   for (RuleResultDetail detail : result.getDetails()) {
     AssertJUnit.assertEquals(
         String.format("Password matches the illegal sequence '%s'.", "&&&&&"),
         DEFAULT_RESOLVER.resolve(detail));
     AssertJUnit.assertNotNull(EMPTY_RESOLVER.resolve(detail));
   }
 }
  /**
   * Used to verify that IndexInput.readByte method reads correctly the whole file content comparing
   * the result with the expected sequence of bytes
   *
   * @param dir The Directory containing the file to verify
   * @param fileName The file name to read
   * @param contentFileSizeExpected The size content file expected
   * @throws IOException
   */
  private void assertReadByteWorkingCorrectly(
      Directory dir, String fileName, final int contentFileSizeExpected) throws IOException {
    IndexInput indexInput = dir.openInput(fileName);
    AssertJUnit.assertEquals(contentFileSizeExpected, indexInput.length());
    RepeatableLongByteSequence bytesGenerator = new RepeatableLongByteSequence();

    for (int i = 0; i < contentFileSizeExpected; i++) {
      AssertJUnit.assertEquals(bytesGenerator.nextByte(), indexInput.readByte());
    }
    indexInput.close();
  }
  /**
   * Test method for {@link edu.ltu.stringreporter.StringReporter#getWordLength(java.lang.String)} .
   */
  @Test
  public void testGetWordLength() {
    String w = "kiran";
    int wLength = w.trim().length();

    // Test that length is same
    AssertJUnit.assertEquals(wLength, StringReporter.getWordLength("kiran"));

    // Test that length is correct for hyphenated words
    AssertJUnit.assertEquals(13, StringReporter.getWordLength("computer-aided"));
  }
 @Test(dependsOnMethods = "testRunningOnMultipleCaches")
 public void verifyIntendedChunkCachesUsage() {
   int chunks = 0;
   for (Object key : chunkCache.keySet()) {
     chunks++;
     AssertJUnit.assertEquals(ChunkCacheKey.class, key.getClass());
     Object value = chunkCache.get(key);
     AssertJUnit.assertEquals(byte[].class, value.getClass());
   }
   assert chunks != 0;
 }
  @Test
  public void pojoTest()
      throws ObjectContextDeserializationException, JsonParseException, IOException {
    Tweet tweet = new Tweet();
    tweet.setUser("aloiscochard");
    tweet.setMessage("#ElasticSearch: You know, for search !");
    tweet.setDate(new Date());

    context.add(Tweet.class);

    try {
      // Create
      node.client().admin().indices().prepareCreate("twitter").execute().actionGet();
    } catch (RemoteTransportException e) {
      // (AGR) Ignore 'Index already exists'
    }

    // Mapping
    node.client()
        .admin()
        .indices()
        .preparePutMapping("twitter")
        .setType(TEST_TYPE)
        .setSource(context.getMapping(Tweet.class))
        .execute()
        .actionGet();
    // Add
    node.client()
        .prepareIndex("twitter", "tweet", "1")
        .setSource(context.write(tweet))
        .execute()
        .actionGet();
    // Refresh
    node.client().admin().indices().prepareRefresh("twitter").execute().actionGet();
    // Search
    SearchResponse searchResponse =
        node.client()
            .prepareSearch("twitter")
            .setSearchType(SearchType.DFS_QUERY_AND_FETCH)
            .setQuery(QueryBuilders.termQuery("user", "aloiscochard"))
            .setExplain(true)
            .execute()
            .actionGet();
    for (SearchHit hit : searchResponse.getHits()) {
      Tweet t = context.read(hit);
      AssertJUnit.assertNotNull(t);
      AssertJUnit.assertEquals(tweet.getUser(), t.getUser());
      AssertJUnit.assertEquals(tweet.getMessage(), t.getMessage());
      AssertJUnit.assertEquals(tweet.getDate(), t.getDate());
      return;
    }
    Assert.fail("Expecting *one* match, but got " + searchResponse.getHits().hits().length);
  }