initQueueName();

private void initQueueName() {
    try {
        Method setter = getClass().getMethod("setQueueName",String.class);
        setter.invoke(this,this.getQueueName());
    } catch (NoSuchMethodException ignored) {
    } catch (Exception e) {
        log.error("",e);
    }
}

@Override
protected void logout() {
    gotoPage("/logout.action");
}

//        assertTextNotInElement("content","error");

<properties>
    <confluence.version>2.10.1</confluence.version>
    <atlassian.product.test-lib.version>1.4.2</atlassian.product.test-lib.version>
    <atlassian.product.data.version>2.10</atlassian.product.data.version>
    <confluence.plugin.bundled>true</confluence.plugin.bundled>
    <confluence.jars.to.remove.regex.list>${basedir}/test/resources/jar-files-to-remove-from-bundle.txt</confluence.jars.to.remove.regex.list>
</properties>

<build>
    ...
    <testSourceDirectory>test</testSourceDirectory>
    <testResources>
        <testResource>
            <directory>test/resources</directory>
            <includes>
                <include>**/*.*</include>
            </includes>
        </testResource>
    </testResources>                          
    ...
</build>

public class AbstractAwpWebTestCase extends AbstractConfluencePluginWebTestCase {
    protected void setUp() throws Exception {
        super.setUp();
        SpaceHelper spaceHelper;
        spaceHelper = getSpaceHelper();
        spaceHelper.setKey(SPACE_KEY);
        spaceHelper.setName("AWP Test Space");
        spaceHelper.setDescription("AWP Test Space");
        assertTrue(spaceHelper.create());

        configureSpacePermissions();

        enableMacro( "workflow");
        enableMacro("include-segment");
        enableMacro("send-email");
        configurePlugin();
        configureUsers();
        loadRequiredPlugins();
    }
    ...
}

private void configureSpacePermissions() throws Exception {
    gotoPage("/spaces/editspacepermissions.action?key=" + SPACE_KEY);
    setFormElement("groupsToAdd",GROUP_CONFLUENCEUSERS);
    submit("groupsToAddButton");

    gotoPage("/spaces/editspacepermissions.action?key=" + SPACE_KEY);
    checkCheckbox("confluence_checkbox_viewspace_group_confluence-users");
    checkCheckbox("confluence_checkbox_editspace_group_confluence-users");
    checkCheckbox("confluence_checkbox_exportpage_group_confluence-users");

    checkCheckbox("confluence_checkbox_removepage_group_confluence-users");
    checkCheckbox("confluence_checkbox_editblog_group_confluence-users");
    checkCheckbox("confluence_checkbox_comment_group_confluence-users");
    checkCheckbox("confluence_checkbox_createattachment_group_confluence-users");
    submit();
}

protected void enableMacro(String name) throws Exception {
    gotoPage("/admin/plugins.action?mode=enable&moduleKey=com.comalatech.workflow%3A" + name);
    assertEquals(200,getDialog().getResponse().getResponseCode());
}

private void loadRequiredPlugins() throws Exception {
    ConfluenceWebTester confluenceWebTester = getConfluenceWebTester();
    File plugin = new File(SystemUtils.JAVA_IO_TMPDIR,"metadata-2.1.0.jar");
    InputStream in = null;
    OutputStream out = null;
    try {
        in = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("metadata-2.1.0.jar"));
        out = new BufferedOutputStream(new FileOutputStream(plugin));
        IOUtils.copy(in, out);
    } finally {
        IOUtils.closeQuietly(out);
        IOUtils.closeQuietly(in);
    }
    confluenceWebTester.setConfluencePluginJar(plugin);
    confluenceWebTester.setConfluencePluginName("Metadata Plugin");
    installPlugin();
}

jQuery(document).ready(initStickyNotes);

function initStickyNotes() {
    jQuery(".wiki-content").find("h1, h2, h3, h4, h5").each(setSectionsIds);
    jQuery(".existing-note").each(setExistingNote);
    jQuery(".sticky-action").each(setStickyAction);
}

function setSectionsIds() {
    var jthis = jQuery(this);
    var content = jthis.text();
    var id;
    id = 'sticky_' + content.replace(/\W/g, '').toLowerCase();
   jthis.append("<div class='sticky-action' id='" + id + "'><span class='sticky-icon'></span></div>");
}

function setExistingNote() {
    var noteid = jQuery(this).html();
    toggleActionIcon(jQuery("#" + noteid), true);
}

function toggleActionIcon(section, hasNotes) {
    if (hasNotes) {
        section.addClass("sticky-notes");
        section.find(".sticky-icon").addClass("has-notes");
    } else {
        section.removeClass("sticky-notes");
        section.find(".sticky-icon").removeClass("has-notes");
    }
}

function setStickyAction() {
    setActionIcon(jQuery(this), true);
}

function setActionIcon(section, pinNote) {
    if (section.hasClass("sticky-notes")) {
        section.hover(hoverInNotes, hoverOutNotes);
        section.find(".sticky-icon").click(pinStickyNote);
    } else {
        section.find(".sticky-icon").click(addStickyNote);
        section.hover(function() {}, function() {});
    }
}

function hoverInNotes() {
    var jthis = jQuery(this);
    if (! jthis.find(".sticky").length) {
        openNote(jthis);
    }
}

function openNote(section) {
    var id = section.attr("id");
    var popup = createPopup(section);
    var uri = makeUri("get") + "&noteId=" + id;
    popup.load(uri, function() {
        if (stickyReadOnly) {
            jQuery(this).sticky().find(".sticky-add").hide();
            jQuery(this).find(".sticky-delete").hide();
        } else {
            jQuery(this).sticky().find(".sticky-add").click(addStickyNote);
            jQuery(this).find(".sticky-delete").click(deleteStickyNote);
        }
    });
}

function hoverOutNotes() {
    var popup = jQuery(this).find(".sticky-popup");
    if (! popup.find(".sticky-pinned").length) {
        popup.remove();
    }
}

public class DocumentIndexer {

    private Method addMethod;
    public DocumentIndexer() {
        Class fieldClass;
        try {
            fieldClass = Class.forName("org.apache.lucene.document.Fieldable");
        } catch (ClassNotFoundException e) {
            try {
                fieldClass = Class.forName("org.apache.lucene.document.Field");
            } catch (ClassNotFoundException e1) {
                throw new RuntimeException(e);
            }
        }
        try {
            addMethod = Document.class.getMethod("add", new Class[] {fieldClass});
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void add(Document document, String key, String value) {
        try {
            Field field = new Field(key, value, Field.Store.YES,Field.Index.TOKENIZED);
            addMethod.invoke(document,new Object[] {field});
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

package com.comalatech.confluence.workflow.wrappers.caching;
public interface Cache  {

    public String getName();

    public Object get(Object key);

    public void put(Object key, Object value);

    public void remove(Object key);

    public void removeAll();

package com.comalatech.confluence.workflow.wrappers.caching;
public interface CacheManager {

    public Cache getCache(String name);    
}

package com.comalatech.confluence.workflow.wrappers.caching;

import com.atlassian.spring.container.ContainerManager;

import java.lang.reflect.Method;

public class WrappedCacheManager implements CacheManager {
    private static Method getNameMethod;
    private static Method getMethod;
    private static Method putMethod;
    private static Method removeMethod;
    private static Method removeAllMethod;

    public Cache getCache(String name) {
        Object cacheManager = ContainerManager.getComponent("cacheManager");
        if (cacheManager == null) {
            throw new RuntimeException("cannot get cacheManager");
        }
        try {
            Method m = cacheManager.getClass().getMethod("getCache", new Class [] {String.class});
            Object cache = m.invoke(cacheManager,new Object[] {name});
            if (getNameMethod == null) {
                initMethods(cache.getClass());
            }
            return new WrappedCache(cache);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private void initMethods(Class cacheClass) {
        try {
            getNameMethod = cacheClass.getMethod("getName",new Class[] {});
            getMethod = cacheClass.getMethod("get",new Class[] {Object.class});
            putMethod = cacheClass.getMethod("put",new Class[] {Object.class, Object.class});
            removeMethod = cacheClass.getMethod("remove",new Class[] {Object.class});
            removeAllMethod = cacheClass.getMethod("removeAll",new Class[] {} );
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    private class WrappedCache implements Cache {

        private Object cache;

        private WrappedCache(Object cache) {
            this.cache = cache;
        }

        public String getName() {
            try {
                return (String)getNameMethod.invoke(cache,new Object[] {});
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public Object get(Object key) {
            try {
                return getMethod.invoke(cache,new Object[] {key});
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public void put(Object key, Object value) {
            try {
                putMethod.invoke(cache,new Object[] {key, value});
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public void remove(Object key) {
            try {
                removeMethod.invoke(cache,new Object[] {key});
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public void removeAll() {
            try {
                removeAllMethod.invoke(cache,new Object[] {});
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class MyViewPageAction extends ViewPageAction implements PageAware {
    ...
}

public class MyViewPageAction28 extends MyViewPageAction implements PageAware, CommentAware {
    public WebInterfaceContext getWebInterfaceContext() {
        DefaultWebInterfaceContext result = new DefaultWebInterfaceContext(super.getWebInterfaceContext());
        if (getClass().equals(MyViewPageAction28.class)) {
            result.setParameter(ViewingContentCondition.CONTEXT_KEY, Boolean.TRUE);
        }
        return result;
    }
}

<xwork name="Approvals Page Actions, extension for 2.8" key="myactions28" state="disabled">
    <package name="pages" extends="pages" namespace="/pages">
        <default-interceptor-ref name="validatingStack"/>
        <action name="viewpage" class="com.comalatech.confluence.workflow.actions.MyViewPageAction28">
        ....
        </action>
    </package>
</xwork>

public class WorkflowsInitializer implements StateAware {
    public void enabled() {
        boolean is2point8 = Integer.parseInt(GeneralUtil.getBuildNumber()) >= 1314;
        if (is2point8) {
            pluginController.enablePluginModule("com.comalatech.workflow:myactions28");
        } else {
            pluginController.disablePluginModule("com.comalatech.workflow:myactions28");
        }
    }    
}