@Test
public void testAdditionalAdminUser() throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException {
    JackrabbitSession jackrabbitSession = (JackrabbitSession) admin;
    Authorizable vip = jackrabbitSession.getUserManager().getAuthorizable(TEST_USER);
    assertNull("test user must not exist", vip);

    jackrabbitSession.getUserManager().createUser(TEST_USER, TEST_USER);
    admin.save();

    Session session = repository.login(new SimpleCredentials(TEST_USER, TEST_USER.toCharArray()));
    try {
        assertTrue(
                "\"" + TEST_USER + "\" is additional admin/system thus should have admin permissions",
                AdminPermissionChecker.hasAdministrativePermissions(session, TEST_USER));
    } finally {
        session.logout();
    }
}
 

@Override
public AccessControlManager getAccessControlManager() throws UnsupportedRepositoryOperationException, RepositoryException {
    AccessControlManager manager = this.wrappedSession.getAccessControlManager();
    return manager instanceof JackrabbitAccessControlManager ?
            new JackrabbitAccessControlManagerWrapper(this, (JackrabbitAccessControlManager) manager) :
            new AccessControlManagerWrapper<>(this, manager);
}
 

@Override
public ObservationManager getObservationManager() throws UnsupportedRepositoryOperationException, RepositoryException {
    if (observationManager == null) {
        observationManager = new ObservationManagerImpl();
    }
    return observationManager;
}
 

@Override
public Node storeAsNode(String absPath) throws ItemExistsException, PathNotFoundException, VersionException,
    ConstraintViolationException, LockException, UnsupportedRepositoryOperationException, RepositoryException {
    return null;
}
 

@Override
public JackrabbitAccessControlPolicy[] getApplicablePolicies(Principal principal) throws AccessDeniedException, AccessControlException, UnsupportedRepositoryOperationException, RepositoryException {
    return delegate.getApplicablePolicies(principal);
}
 

@Override
public JackrabbitAccessControlPolicy[] getPolicies(Principal principal) throws AccessDeniedException, AccessControlException, UnsupportedRepositoryOperationException, RepositoryException {
    return delegate.getPolicies(principal);
}
 

@Override
public AccessControlPolicy[] getEffectivePolicies(Set<Principal> principals) throws AccessDeniedException, AccessControlException, UnsupportedRepositoryOperationException, RepositoryException {
    return delegate.getEffectivePolicies(principals);
}
 

@Override
public void registerNamespace(String prefix, String uri) throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException {
    jcr.registerNamespace(prefix, uri);
}
 

@Override
public void unregisterNamespace(String prefix) throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException {
    jcr.unregisterNamespace(prefix);
}
 

@Override
public Node storeAsNode(String absPath) throws ItemExistsException, PathNotFoundException, VersionException, ConstraintViolationException, LockException, UnsupportedRepositoryOperationException, RepositoryException {
    return sessionWrapper.getObjectWrapper().wrap(sessionWrapper, delegate.storeAsNode(absPath));
}
 

@Override
public void restore(Version[] versions, boolean removeExisting) throws ItemExistsException, UnsupportedRepositoryOperationException, VersionException, LockException, InvalidItemStateException, RepositoryException {
    delegate.restore(versions, removeExisting);
}
 

@Override
public void createWorkspace(String name) throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException {
    delegate.createWorkspace(name);
}
 

@Override
public void createWorkspace(String name, String srcWorkspace) throws AccessDeniedException, UnsupportedRepositoryOperationException, NoSuchWorkspaceException, RepositoryException {
    delegate.createWorkspace(name, srcWorkspace);
}
 

@Override
public void deleteWorkspace(String name) throws AccessDeniedException, UnsupportedRepositoryOperationException, NoSuchWorkspaceException, RepositoryException {
    delegate.deleteWorkspace(name);
}
 

@Override
public LockManager getLockManager() throws UnsupportedRepositoryOperationException, RepositoryException {
    return delegate.getLockManager();
}
 

@Override
public ObservationManager getObservationManager() throws UnsupportedRepositoryOperationException, RepositoryException {
    return delegate.getObservationManager();
}
 

@Override
public VersionManager getVersionManager() throws UnsupportedRepositoryOperationException, RepositoryException {
    return delegate.getVersionManager();
}
 

@Override
public void orderBefore(String srcChildRelPath, String destChildRelPath) throws UnsupportedRepositoryOperationException, VersionException, ConstraintViolationException, ItemNotFoundException, LockException, RepositoryException {
    this.delegate.orderBefore(srcChildRelPath, destChildRelPath);
}
 

@Override
public String getUUID() throws UnsupportedRepositoryOperationException, RepositoryException {
    return this.delegate.getUUID();
}
 

@Override
public Version checkin() throws VersionException, UnsupportedRepositoryOperationException, InvalidItemStateException, LockException, RepositoryException {
    return this.delegate.checkin();
}
 

@Override
public void checkout() throws UnsupportedRepositoryOperationException, LockException, ActivityViolationException, RepositoryException {
    this.delegate.checkout();
}
 

@Override
public void doneMerge(Version version) throws VersionException, InvalidItemStateException, UnsupportedRepositoryOperationException, RepositoryException {
    this.delegate.doneMerge(version);
}
 

@Override
public void cancelMerge(Version version) throws VersionException, InvalidItemStateException, UnsupportedRepositoryOperationException, RepositoryException {
    this.delegate.cancelMerge(version);
}
 

@Override
public void restore(String versionName, boolean removeExisting) throws VersionException, ItemExistsException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
    this.delegate.restore(versionName, removeExisting);
}
 

@Override
public void restore(Version version, boolean removeExisting) throws VersionException, ItemExistsException, InvalidItemStateException, UnsupportedRepositoryOperationException, LockException, RepositoryException {
    this.delegate.restore(version, removeExisting);
}
 

@Override
public void restore(Version version, String relPath, boolean removeExisting) throws PathNotFoundException, ItemExistsException, VersionException, ConstraintViolationException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
    this.delegate.restore(version, relPath, removeExisting);
}
 

@Override
public void restoreByLabel(String versionLabel, boolean removeExisting) throws VersionException, ItemExistsException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
    this.delegate.restoreByLabel(versionLabel, removeExisting);
}
 

@Override
public VersionHistory getVersionHistory() throws UnsupportedRepositoryOperationException, RepositoryException {
    return this.delegate.getVersionHistory();
}
 

@Override
public Version getBaseVersion() throws UnsupportedRepositoryOperationException, RepositoryException {
    return this.delegate.getBaseVersion();
}
 

@Override
public Lock lock(boolean isDeep, boolean isSessionScoped) throws UnsupportedRepositoryOperationException, LockException, AccessDeniedException, InvalidItemStateException, RepositoryException {
    return sessionWrapper.getObjectWrapper().wrap(sessionWrapper, delegate.lock(isDeep, isSessionScoped));
}