public void testLengthBinaryLiteral() throws RepositoryException { node.setProperty(propertyName1, "abc"); superuser.save(); String length = String.valueOf(node.getProperty(propertyName1).getLength()); Binary b = vf.createBinary(new ByteArrayInputStream(length.getBytes())); try { executeQueries(propertyName1, QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO, vf.createValue(b)); } finally { b.dispose(); } }
protected final Value valueFor( InputStream stream ) throws RepositoryException { Binary binary = jcrValueFactory.createBinary(stream); return jcrValueFactory.createValue(binary); }
ValueFactory factory = session.getValueFactory(); InputStream is = new ByteArrayInputStream(fileContent); Binary binary = factory.createBinary(is); Value value = factory.createValue(binary); n.setProperty("jcr:data", value);
/** * Serialize the given <code>object</code> into a binary JCR value. * * @param session to use * @param object to serialize * @return a binary value containing the serialized object * @throws RepositoryException */ public static Value createBinaryValueFromObject(Session session, Object object) throws RepositoryException { final ValueFactory valueFactory = session.getValueFactory(); return valueFactory.createValue(valueFactory.createBinary(new ByteArrayInputStream(objectToBytes(object)))); }
/** * Stores the content of the given InputStream into a binary "jcr:data" property of the given Node, then closes * the InputStream. * @param is the InputStream whose contents will be stored * @param resourceNode the JCR Node where the content will be stored */ protected void storeBinary(InputStream is, Node resourceNode) throws IOException, RepositoryException { // store content as Binary BufferedInputStream bis = new BufferedInputStream(is); Binary bin = resourceNode.getSession().getValueFactory().createBinary(bis); resourceNode.setProperty(JcrConstants.JCR_DATA, bin); }
@Test public void testCreateValueFromBytesArray() throws Exception { byte[] bytes = new byte[]{'a', 'b'}; ByteArrayInputStream is = new ByteArrayInputStream(bytes); Binary binary = valueFactory.createBinary(is); Value v = syncCtx.createValue(bytes); assertNotNull(v); assertEquals(PropertyType.BINARY, v.getType()); assertEquals(binary, v.getBinary()); }
@FixFor( "MODE-799" ) public void testAutomaticCreationUponSaveOfETagPropertyWhenNodeWithETagMixinHasNewBinaryProperty() throws Exception { session = getHelper().getReadWriteSession(); Node root = getTestRoot(session); Node newNode = root.addNode("someNewNode3"); newNode.addMixin("mix:etag"); session.save(); Binary binary = session.getValueFactory().createBinary(new ByteArrayInputStream("This is the value".getBytes())); root.getNode("someNewNode3").setProperty("binaryProperty", binary); session.save(); String etagValue = root.getNode("someNewNode3").getProperty("jcr:etag").getString(); assertThat(etagValue.trim().length() != 0, is(true)); }
private static void setEmptyHippoTextBinary(final Node node) { String nodePath = null; try { nodePath = node.getPath(); final ByteArrayInputStream emptyByteArrayInputStream = new ByteArrayInputStream(new byte[0]); node.setProperty(HippoNodeType.HIPPO_TEXT, getValueFactory(node).createBinary(emptyByteArrayInputStream)); } catch (RepositoryException e) { log.error("Unable to store empty hippo:text binary for node '"+nodePath+"'", e); } }
private Node createJsonNode(String name) throws RepositoryException, UnsupportedEncodingException { Node test = testRootNode.addNode(name, JcrConstants.NT_FILE); Node content = test.addNode(JcrConstants.JCR_CONTENT, JcrConstants.NT_RESOURCE); content.setProperty(JcrConstants.JCR_DATA, test.getSession().getValueFactory().createBinary(new ByteArrayInputStream(jsondata.getBytes("UTF-8")))); test.getSession().save(); return test; } }
@Override protected void setUp() throws Exception { super.setUp(); test = testRootNode.addNode("test"); test.addMixin(mixReferenceable); superuser.save(); values.add(vf.createValue("value")); values.add(vf.createValue(new BigDecimal(1234))); values.add(vf.createValue(Calendar.getInstance())); values.add(vf.createValue(1.234)); values.add(vf.createValue(true)); values.add(vf.createValue(test)); values.add(vf.createValue(vf.createBinary( new ByteArrayInputStream(new byte[0])))); }
protected Property setProperty(Node node, int length) throws RepositoryException { Random rand = new Random(); byte[] data = new byte[length]; rand.nextBytes(data); Binary b = vf.createBinary(new ByteArrayInputStream(data)); //System.out.println(b.getClass() + ": " + System.identityHashCode(b)); try { return node.setProperty(propertyName1, b); } finally { b.dispose(); } }
@Test public void collectBinary() throws RepositoryException { // GIVEN final Node node = session.getRootNode().addNode("node", NodeTypes.Resource.NAME); final Binary binary = session.getValueFactory().createBinary(new ByteArrayInputStream(new byte[]{})); final Property property = node.setProperty(PropertyType.TYPENAME_BINARY, binary); aggregationState.setHandle(property.getPath()); // WHEN boolean success = filter.collect(); // THEN assertTrue(success); assertNotNull(aggregationState.getFile()); assertEquals("/node", aggregationState.getHandle()); }
public void testLengthDoubleLiteral() throws RepositoryException { node.setProperty(propertyName1, "abc"); superuser.save(); double length = node.getProperty(propertyName1).getLength(); executeQueries(propertyName1, QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO, vf.createValue(length)); }
/** * Tests if adding a property with <code>Node.setProperty(String, * Calendar)</code> works with <code>parentNode.save()</code> */ public void testNewCalendarPropertyParent() throws Exception { testNode.setProperty(propertyName1, c1); testRootNode.getSession().save(); assertEquals("Setting property with Node.setProperty(String, Calendar) and parentNode.save() not working", vf.createValue(c1), testNode.getProperty(propertyName1).getValue()); }
public void testSimpleWeakReferences() throws RepositoryException { Node ref = testRootNode.addNode(nodeName2, testNodeType); ref.addMixin(mixReferenceable); superuser.save(); Node n = testRootNode.addNode(nodeName1, testNodeType); n.setProperty("myref", superuser.getValueFactory().createValue(ref, true)); superuser.save(); assertEquals("ref", ref.getPath(), n.getProperty("myref").getNode().getPath()); checkReferences("refs", ref.getReferences()); checkReferences("refs", ref.getWeakReferences(), n.getPath() + "/myref"); }
public void testMVReferences() throws RepositoryException { Node ref0 = testRootNode.addNode(nodeName2, testNodeType); ref0.addMixin(mixReferenceable); Node ref1 = testRootNode.addNode(nodeName3, testNodeType); ref1.addMixin(mixReferenceable); superuser.save(); Node n = testRootNode.addNode(nodeName1, testNodeType); Value[] vs = new Value[]{ superuser.getValueFactory().createValue(ref0), superuser.getValueFactory().createValue(ref1) }; n.setProperty("myref", vs); superuser.save(); assertEquals("ref0", ref0.getIdentifier(), n.getProperty("myref").getValues()[0].getString()); assertEquals("ref1", ref1.getIdentifier(), n.getProperty("myref").getValues()[1].getString()); checkReferences("refs", ref0.getReferences(), n.getPath() + "/myref"); checkReferences("refs", ref1.getReferences(), n.getPath() + "/myref"); }
public void testMultiValues() throws Exception { superuser.importXML(targetPath, getImportStream(), ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW); superuser.save(); Node n = superuser.getNode(targetPath).getNode(nodeName4); Property p = n.getNode(nodeName2).getProperty("test:multiProperty"); assertTrue(p.isMultiple()); assertTrue(p.getDefinition().isMultiple()); Value[] expected = new Value[] {vf.createValue("v1"), vf.createValue("v2")}; Assert.assertArrayEquals(expected, p.getValues()); }
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()); } }
public void testSingleValue() throws RepositoryException { Value weakRef = vf.createValue(target, true); referring.setProperty(propertyName1, weakRef); superuser.save(); PropertyIterator it = target.getWeakReferences(); assertTrue("no weak references returned", it.hasNext()); Property p = it.nextProperty(); assertEquals("wrong weak reference property", referring.getProperty(propertyName1).getPath(), p.getPath()); assertFalse("no more weak references expected", it.hasNext()); }
void markDownstream(final InitializeItem reloadItem) throws RepositoryException { final Value[] upstreamItemIds; final Value upstreamItemId = itemNode.getSession().getValueFactory().createValue(reloadItem.getItemNode().getIdentifier()); if (itemNode.hasProperty(HIPPO_UPSTREAMITEMS)) { List<Value> values = new ArrayList<>(Arrays.asList(itemNode.getProperty(HIPPO_UPSTREAMITEMS).getValues())); values.add(upstreamItemId); upstreamItemIds = values.toArray(new Value[values.size()]); } else { upstreamItemIds = new Value[] { upstreamItemId }; } itemNode.setProperty(HIPPO_UPSTREAMITEMS, upstreamItemIds); itemNode.setProperty(HIPPO_STATUS, ITEM_STATUS_PENDING); }