How to use

getType

method

in

javax.jcr.Property

/**
 * @inheritDoc
 */
public int getType() throws RepositoryException {
  return property.getType();
}

/** {@inheritDoc} */
public int getType() throws RepositoryException, RemoteException {
  try {
    return property.getType();
  } catch (RepositoryException ex) {
    throw getRepositoryException(ex);
  }
}

@Override
public boolean evaluateTyped(Property property) {
  try {
    return !excludedNames.contains(property.getName()) && !excludedTypes.contains(PropertyType.nameFromValue(property.getType()));
  } catch (RepositoryException e) {
    return false;
  }
}

@Override
public int getType() {
  if (isExist()) {
    try {
      return getJCRProperty().getType();
    } catch (Exception e) {
      log.warn("Unable to read property type for {}", name);
    }
  }
  return PropertyType.UNDEFINED;
}

  public void testNotNormalizedPathValue() throws RepositoryException {
    ValueFactory vf = superuser.getValueFactory();
    Value pathValue = vf.createValue("/a/../b/./c/dd/..", PropertyType.PATH);

    Property p = testRootNode.setProperty(propertyName1, pathValue);

    assertEquals(PropertyType.PATH, p.getType());
    assertEquals(pathValue.getString(), p.getValue().getString());
    assertEquals(pathValue, p.getValue());                
  }
}

private void forStringCodecProperties(final Node node, final PropertyVisitor visitor) throws RepositoryException {
  final PropertyIterator properties = node.getProperties();
  while (properties.hasNext()) {
    final Property property = properties.nextProperty();
    if (!property.isMultiple()
        && property.getType() == PropertyType.STRING
        && !property.getName().contains(":")) {
      visitor.visit(property);
    }
  }
}

public void testRemoveReferenced1() throws RepositoryException {
  Node ref = testRootNode.addNode(nodeName1, testNodeType);
  ref.addMixin(mixReferenceable);
  superuser.save();
  Node n1 = testRootNode.addNode(nodeName2, testNodeType);
  n1.setProperty("ref", ref);
  assertEquals(PropertyType.REFERENCE, n1.getProperty("ref").getType());
  superuser.save();
  ref.remove();
  n1.remove();
  superuser.save();
}

public void testSetPropertyConvertMultiValued() throws RepositoryException {
  Node n = testRootNode.addNode(nodeName1, "test:canSetProperty");
  // must convert to long there is no other definition for this property
  Property p = n.setProperty("LongMultiple", new String[]{"123", "456"});
  assertEquals(PropertyType.nameFromValue(PropertyType.LONG),
      PropertyType.nameFromValue(p.getType()));
}

@Test
public void setPropertyStringStringInt() throws RepositoryException {
  // GIVEN
  Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT);
  assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class));
  // WHEN
  node.setProperty("test", "true", PropertyType.BOOLEAN);
  // THEN
  assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType());
}

@Test
public void setPropertyStringStringArrayInt() throws RepositoryException {
  // GIVEN
  Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT);
  assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class));
  String[] values = {"true"};
  // WHEN
  node.setProperty("test", values, PropertyType.BOOLEAN);
  // THEN
  assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType());
}

public void testGetTypeOfPredecessors() throws RepositoryException {
  Node node = testRootNode.addNode(nodeName1, testNodeType);
  node.addMixin(mixVersionable);
  superuser.save();
  VersionManager vMgr = superuser.getWorkspace().getVersionManager();
  vMgr.checkin(node.getPath());
  assertEquals(PropertyType.nameFromValue(PropertyType.REFERENCE),
      PropertyType.nameFromValue(node.getProperty(jcrPredecessors).getType()));
}

public void testStringKey() throws Exception {
 assertNull(o.getString());
 Map<String, Object> map = o.getProperties();
 map.put("string_property", "foo");
 assertEquals("foo", map.get("string_property"));
 assertEquals(PropertyType.STRING, node.getProperty("string_property").getType());
 assertEquals("foo", node.getProperty("string_property").getString());
 if (getConfig().isStateCacheDisabled()) {
  node.setProperty("string_property", (String)null);
  assertEquals(null, map.get("string_property"));
 }
}

@Test
public void setPropertyStringValueInt() throws RepositoryException {
  // GIVEN
  Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT);
  assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class));
  // WHEN
  node.setProperty("test", ValueFactoryImpl.getInstance().createValue("true"), PropertyType.BOOLEAN);
  // THEN
  assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType());
}

@Test
public void setPropertyStringValueArrayInt() throws RepositoryException {
  // GIVEN
  Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT);
  assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class));
  Value[] values = {ValueFactoryImpl.getInstance().createValue("true")};
  // WHEN
  node.setProperty("test", values, PropertyType.BOOLEAN);
  // THEN
  assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType());
}

@Test
public void updateFrom534CheckSuperuserRolePermissionAreUpdated() throws Exception {
  // GIVEN
  Node roleNode = NodeUtil.createPath(userRolesSession.getRootNode(), "superuser", NodeTypes.Role.NAME);
  Node permissionNode = NodeUtil.createPath(roleNode, "acl_forum", NodeTypes.Role.NAME);
  Node wrongPermissionNode = NodeUtil.createPath(permissionNode, "0", NodeTypes.ContentNode.NAME);
  wrongPermissionNode.setProperty("permissions", "63");
  // WHEN
  executeUpdatesAsIfTheCurrentlyInstalledVersionWas(Version.parseVersion("5.3.4"));
  // THEN
  assertThat(wrongPermissionNode.getProperty("permissions").getType(), CoreMatchers.is(PropertyType.LONG));
}

@Test
public void addLongProperty() throws Exception {
  final Long propertyValue = 666L;
  final ValueFactory valueFactory = mock(ValueFactory.class);
  when(valueFactory.createValue(propertyValue)).thenReturn(new MockValue(propertyValue));
  session.setValueFactory(valueFactory);
  final NodeOperation op = Ops.addProperty(PROPERTY_NAME, propertyValue);
  op.exec(rootNode, errorHandler);
  assertThat(rootNode, hasProperty(PROPERTY_NAME, propertyValue));
  assertThat("We want to make sure the property is created with the correct type",
      rootNode.getProperty(PROPERTY_NAME).getType(), is(PropertyType.LONG));
}

protected DefinitionPropertyImpl exportProperty(final Property property, DefinitionNodeImpl definitionNode) throws RepositoryException {
  if (property.isMultiple()) {
    return definitionNode.addProperty(property.getName(), ValueType.fromJcrType(property.getType()),
        valuesFrom(property, definitionNode));
  } else {
    final ValueImpl value = valueFrom(property, definitionNode);
    final DefinitionPropertyImpl targetProperty = definitionNode.addProperty(property.getName(), value);
    value.setParent(targetProperty);
    return targetProperty;
  }
}

@Test
public void testGetType() throws Exception {
  String stringValue = "string";
  Property property = new MockProperty("test", new MockValue(stringValue), null);
  assertEquals(PropertyType.STRING, property.getType());
}

private static void assertVersionablePath(final VersionHistory history, final String versionablePath)
    throws RepositoryException {
  final String workspaceName = history.getSession().getWorkspace().getName();
  assertTrue(history.isNodeType(MIX_REP_VERSIONABLE_PATHS));
  assertTrue(history.hasProperty(workspaceName));
  final Property pathProperty = history.getProperty(workspaceName);
  assertEquals(PropertyType.PATH, pathProperty.getType());
  assertEquals(versionablePath, pathProperty.getString());
}

public void testStringRequiredTypeBoolean() throws Exception {
  Value stringValue = superuser.getValueFactory().createValue("true", PropertyType.STRING);
  Property p = node.setProperty(BOOLEAN_PROP_NAME, stringValue);
  assertEquals(PropertyType.BOOLEAN, p.getType());
  assertEquals(PropertyType.BOOLEAN, p.getValue().getType());
  assertTrue(p.getBoolean());
  PropertyDefinition def = p.getDefinition();
  assertEquals(PropertyType.BOOLEAN, def.getRequiredType());
  assertEquals(NT_NAME, def.getDeclaringNodeType().getName());
}