public void testResume() throws Exception {
    assertTrue(fromSuite());
    testSuspend();
    assertTrue("suspend must succeed to create the output first", output != null);

    assertEquals(output.length(), 562);

    final Object o = loadJDK(output);

    assertTrue(o instanceof Continuation);
    final Continuation c1 = (Continuation) o;
    final StackRecorder sr1 = (StackRecorder) PrivateAccessor.getField(c1, "stackRecorder");
    final Runnable r1 = (Runnable) PrivateAccessor.getField(sr1, "runnable");
    assertEquals(SimpleSerializable.class.getName(), r1.getClass().getName());

    final SimpleSerializable ss1 = (SimpleSerializable) r1;
    assertTrue(ss1.g == 0);
    assertTrue(ss1.l == 0);
    final Continuation c2 = Continuation.continueWith(c1);
    final StackRecorder sr2 = (StackRecorder) PrivateAccessor.getField(c2, "stackRecorder");
    final Runnable r2 = (Runnable) PrivateAccessor.getField(sr2, "runnable");
    assertEquals(SimpleSerializable.class.getName(), r2.getClass().getName());
    final SimpleSerializable ss2 = (SimpleSerializable) r2;
    assertTrue(ss2.g == 1);
    assertTrue(ss2.l == 1);
    assertTrue(r1 == r2);
  }
  /** Test of resolveChannelName method from {@link MessageRecipient} */
  public void testResolveChannelName() throws Exception {
    MessageRecipient messageRecipient = new MessageRecipient();

    // This is necessary to remove the need to create the entire Volantis
    // bean _just_ to get two Strings out...
    PrivateAccessor.setField(
        messageRecipient, "messageRecipientInfo", new MessageRecipientInfoTestHelper());

    messageRecipient.resolveChannelName(false);

    assertEquals(
        "Resolved channel not equal to default", "smtp", messageRecipient.getChannelName());

    messageRecipient.setChannelName("aardvark");
    messageRecipient.resolveChannelName(false);

    assertEquals(
        "Resolved channel overrode current value", "aardvark", messageRecipient.getChannelName());

    messageRecipient.resolveChannelName(true);

    assertEquals(
        "Resolved channel did not override current value",
        "smtp",
        messageRecipient.getChannelName());
  }
 /**
  * Helper method.
  *
  * @param filter the content type.
  * @return true if the filter is in the container, false otherwise.
  */
 private boolean isFilterInContainer(ScriptFilter filter) throws Exception {
   if (filter != null) {
     Map map = (Map) PrivateAccessor.getField(module, "scriptFilters");
     if (map != null) {
       return map.containsKey(filter.getContentType());
     }
   }
   return false;
 }
  @Before
  public void setup() throws Exception {
    SlingSettingsService settings = mock(SlingSettingsService.class);
    slingId = UUID.randomUUID().toString();
    when(settings.getSlingId()).thenReturn(slingId);

    hello = new HelloWorldModel();
    PrivateAccessor.setField(hello, "settings", settings);
    hello.init();
  }
  @Before
  public void setup() throws Exception {
    resource = context.create().resource("app/content/any/resource");
    context.addModelsForPackage("com.thoughtworks.www.samples.models");

    String slingId = UUID.randomUUID().toString();
    when(settings.getSlingId()).thenReturn(slingId);

    buttonModel = context.currentResource(resource).adaptTo(ButtonModel.class);
    PrivateAccessor.setField(buttonModel, "settings", settings);
  }
  public void testFormatExtList_emptyExt() throws Exception, Throwable {
    System.out.println("formatExtList");

    ArrayList exts = new ArrayList();

    String formattedExtList =
        (String)
            PrivateAccessor.invoke(
                Sync4jServlet.class,
                "formatExtListAsProperties",
                new Class[] {ArrayList.class},
                new Object[] {exts});

    assertEquals("", formattedExtList);
  }
  public void testFormatExtList_twoExt() throws Exception, Throwable {
    System.out.println("formatExtList");

    ArrayList exts = new ArrayList();
    exts.add(new Ext("X-funambol-smartslow", new String[0]));
    exts.add(new Ext("X-foo", new String[] {"val1", "val2", "val3"}));

    String formattedExtList =
        (String)
            PrivateAccessor.invoke(
                Sync4jServlet.class,
                "formatExtListAsProperties",
                new Class[] {ArrayList.class},
                new Object[] {exts});

    assertEquals("X-funambol-smartslow,X-foo[val1,val2,val3]", formattedExtList);
  }
  public void testFormatExtList_oneExtWithOnlyName() throws Exception, Throwable {
    System.out.println("formatExtList");

    Ext ext = new Ext("X-funambol-smartslow", new String[0]);
    ArrayList exts = new ArrayList();
    exts.add(ext);

    String formattedExtList =
        (String)
            PrivateAccessor.invoke(
                Sync4jServlet.class,
                "formatExtListAsProperties",
                new Class[] {ArrayList.class},
                new Object[] {exts});

    assertEquals("X-funambol-smartslow", formattedExtList);
  }
  public void testFormatExtList_replaceChar() throws Exception, Throwable {
    System.out.println("formatExtList");

    ArrayList exts = new ArrayList();
    exts.add(new Ext("X-funambol-smartslow", new String[0]));
    exts.add(new Ext("X-fo,o", new String[] {"val1[pippo]", "val,2", "val3[pip,po]"}));
    exts.add(new Ext("X-pippo[pippo]", new String[] {"val[pippo]"}));

    String formattedExtList =
        (String)
            PrivateAccessor.invoke(
                Sync4jServlet.class,
                "formatExtListAsProperties",
                new Class[] {ArrayList.class},
                new Object[] {exts});

    assertEquals(
        "X-funambol-smartslow,X-fo\\,o[val1\\[pippo\\],val\\,2,val3\\[pip\\,po\\]],X-pippo\\[pippo\\][val\\[pippo\\]]",
        formattedExtList);
  }
Example #10
0
  @SuppressWarnings("unchecked")
  private Map<String, RequestProperty> collectContent(Param... kvs) throws Throwable {
    final List<Map.Entry<String, RequestParameter>> params =
        new ArrayList<Map.Entry<String, RequestParameter>>();
    for (int i = 0; i < kvs.length; i++) {
      final Param kv = kvs[i];
      final RequestParameter[] param = new RequestParameter[kv.value.length];
      for (int j = 0; j < kv.value.length; j++) {
        final String strValue = kv.value[j];
        final RequestParameter aparam =
            context.mock(RequestParameter.class, "requestParameter" + i + "#" + j);
        context.checking(
            new Expectations() {
              {
                allowing(aparam).getString();
                will(returnValue(strValue));
              }
            });
        param[j] = aparam;
      }
      final Map.Entry<String, RequestParameter> entry = context.mock(Map.Entry.class, "entry" + i);
      context.checking(
          new Expectations() {
            {
              allowing(entry).getKey();
              will(returnValue(kv.key));
              allowing(entry).getValue();
              will(returnValue(param));
            }
          });
      params.add(entry);
    }

    final Set set = context.mock(Set.class);
    context.checking(
        new Expectations() {
          {
            one(set).iterator();
            will(returnValue(params.iterator()));
          }
        });

    final RequestParameterMap map = context.mock(RequestParameterMap.class);
    context.checking(
        new Expectations() {
          {
            one(map).entrySet();
            will(returnValue(set));
          }
        });

    final SlingHttpServletRequest request = context.mock(SlingHttpServletRequest.class);
    context.checking(
        new Expectations() {
          {
            Vector names = new Vector();
            names.add("./param");

            one(request).getParameterNames();
            will(returnValue(names.elements()));
            one(request).getRequestParameterMap();
            will(returnValue(map));
          }
        });
    final HtmlResponse response = new HtmlResponse();
    response.setPath("/test/path");

    Map<String, RequestProperty> props =
        (Map<String, RequestProperty>)
            PrivateAccessor.invoke(
                new ModifyOperation(),
                "collectContent",
                COLLECT_CLASSES,
                new Object[] {request, response});
    return props;
  }
 /**
  * Unmarshall a Chromosome instance from a given XML Element representation.
  *
  * @param a_activeConfiguration current Configuration object
  * @param a_xmlElement the XML Element representation of the Chromosome
  * @return a new Chromosome instance setup with the data from the XML Element representation
  * @throws ImproperXMLException if the given Element is improperly structured or missing data
  * @throws UnsupportedRepresentationException if the actively configured Gene implementation does
  *     not support the string representation of the alleles used in the given XML document
  * @throws GeneCreationException if there is a problem creating or populating a Gene instance
  * @author Neil Rotstan
  * @since 1.0
  */
 public static Gene[] getGenesFromElement(
     Configuration a_activeConfiguration, Element a_xmlElement)
     throws ImproperXMLException, UnsupportedRepresentationException, GeneCreationException {
   // Do some sanity checking. Make sure the XML Element isn't null and
   // that it in fact represents a set of genes.
   // -----------------------------------------------------------------
   if (a_xmlElement == null || !(a_xmlElement.getTagName().equals(GENES_TAG))) {
     throw new ImproperXMLException(
         "Unable to build Chromosome instance from XML Element: "
             + "given Element is not a 'genes' element.");
   }
   List genes = Collections.synchronizedList(new ArrayList());
   // Extract the nested gene elements.
   // ---------------------------------
   NodeList geneElements = a_xmlElement.getElementsByTagName(GENE_TAG);
   if (geneElements == null) {
     throw new ImproperXMLException(
         "Unable to build Gene instances from XML Element: "
             + "'"
             + GENE_TAG
             + "'"
             + " sub-elements not found.");
   }
   // For each gene, get the class attribute so we know what class
   // to instantiate to represent the gene instance, and then find
   // the child text node, which is where the string representation
   // of the allele is located, and extract the representation.
   // -------------------------------------------------------------
   int numberOfGeneNodes = geneElements.getLength();
   for (int i = 0; i < numberOfGeneNodes; i++) {
     Element thisGeneElement = (Element) geneElements.item(i);
     thisGeneElement.normalize();
     // Fetch the class attribute and create an instance of that
     // class to represent the current gene.
     // --------------------------------------------------------
     String geneClassName = thisGeneElement.getAttribute(CLASS_ATTRIBUTE);
     Gene thisGeneObject;
     Class geneClass = null;
     try {
       geneClass = Class.forName(geneClassName);
       try {
         Constructor constr = geneClass.getConstructor(new Class[] {Configuration.class});
         thisGeneObject = (Gene) constr.newInstance(new Object[] {a_activeConfiguration});
       } catch (NoSuchMethodException nsme) {
         // Try it by calling method newGeneInternal.
         // -----------------------------------------
         Constructor constr = geneClass.getConstructor(new Class[] {});
         thisGeneObject = (Gene) constr.newInstance(new Object[] {});
         thisGeneObject =
             (Gene)
                 PrivateAccessor.invoke(
                     thisGeneObject, "newGeneInternal", new Class[] {}, new Object[] {});
       }
     } catch (Throwable e) {
       throw new GeneCreationException(geneClass, e);
     }
     // Find the text node and fetch the string representation of
     // the allele.
     // ---------------------------------------------------------
     NodeList children = thisGeneElement.getChildNodes();
     int childrenSize = children.getLength();
     String alleleRepresentation = null;
     for (int j = 0; j < childrenSize; j++) {
       Element alleleElem = (Element) children.item(j);
       if (alleleElem.getTagName().equals(ALLELE_TAG)) {
         alleleRepresentation = alleleElem.getAttribute("value");
       }
       if (children.item(j).getNodeType() == Node.TEXT_NODE) {
         // We found the text node. Extract the representation.
         // ---------------------------------------------------
         alleleRepresentation = children.item(j).getNodeValue();
         break;
       }
     }
     // Sanity check: Make sure the representation isn't null.
     // ------------------------------------------------------
     if (alleleRepresentation == null) {
       throw new ImproperXMLException(
           "Unable to build Gene instance from XML Element: "
               + "value (allele) is missing representation.");
     }
     // Now set the value of the gene to that reflect the
     // string representation.
     // -------------------------------------------------
     try {
       thisGeneObject.setValueFromPersistentRepresentation(alleleRepresentation);
     } catch (UnsupportedOperationException e) {
       throw new GeneCreationException(
           "Unable to build Gene because it does not support the "
               + "setValueFromPersistentRepresentation() method.");
     }
     // Finally, add the current gene object to the list of genes.
     // ----------------------------------------------------------
     genes.add(thisGeneObject);
   }
   return (Gene[]) genes.toArray(new Gene[genes.size()]);
 }