Esempio n. 1
0
  public void testTranslateVariablesOpenChar() {
    // just a quick test to see if the open char works
    // most test are done the methods above
    ValueStack stack = ActionContext.getContext().getValueStack();

    Object s = TextParseUtil.translateVariables('$', "foo: ${{1, 2, 3}}, bar: ${1}", stack);
    assertEquals("foo: [1, 2, 3], bar: 1", s);

    Object s2 = TextParseUtil.translateVariables('#', "foo: #{{1, 2, 3}}, bar: #{1}", stack);
    assertEquals("foo: [1, 2, 3], bar: 1", s2);
  }
Esempio n. 2
0
  public void testTranslateVariablesRecursive() {
    ValueStack stack = ActionContext.getContext().getValueStack();
    stack.push(
        new HashMap<String, Object>() {
          {
            put("foo", "${1+1}");
            put("bar", "${${1+2}}");
          }
        });

    Object s = TextParseUtil.translateVariables('$', "foo: ${foo}", stack, String.class, null, 2);
    assertEquals("foo: 2", s);

    s = TextParseUtil.translateVariables('$', "foo: ${bar}", stack, String.class, null, 1);
    assertEquals("foo: ${${1+2}}", s);
  }
Esempio n. 3
0
 public void testMixedOpenChars() throws Exception {
   ValueStack stack = ActionContext.getContext().getValueStack();
   stack.push(
       new HashMap<String, Object>() {
         {
           put("foo", "bar");
         }
       });
   String s = TextParseUtil.translateVariables("${foo}-%{foo}", stack);
   assertEquals("bar-bar", s);
   s = TextParseUtil.translateVariables("%{foo}-${foo}", stack);
   assertEquals(
       "%{foo}-bar",
       s); // this is bad, but it is the only way not to double evaluate passed expression
   stack.pop();
 }
Esempio n. 4
0
 public void testNestedExpression() throws Exception {
   ValueStack stack = ActionContext.getContext().getValueStack();
   stack.push(
       new HashMap<String, Object>() {
         {
           put("foo", "${%{1+1}}");
         }
       });
   String s = TextParseUtil.translateVariables("${foo}", stack);
   assertEquals("${%{1+1}}", s);
   stack.pop();
 }
Esempio n. 5
0
  public void testTranslateVariablesWithEvaluator() throws Exception {
    ValueStack stack = ActionContext.getContext().getValueStack();
    stack.push(
        new Object() {
          public String getMyVariable() {
            return "My Variable ";
          }
        });

    TextParseUtil.ParsedValueEvaluator evaluator =
        new TextParseUtil.ParsedValueEvaluator() {
          public Object evaluate(String parsedValue) {
            return parsedValue.toString() + "Something";
          }
        };

    String result = TextParseUtil.translateVariables("Hello ${myVariable}", stack, evaluator);

    assertEquals(result, "Hello My Variable Something");
  }
Esempio n. 6
0
  public void testTranslateVariablesWithNull() {
    // given
    ValueStack stack = ActionContext.getContext().getValueStack();
    stack.push(
        new HashMap<String, Object>() {
          {
            put("foo", null);
          }
        });

    TextParseUtil.ParsedValueEvaluator evaluator =
        new TextParseUtil.ParsedValueEvaluator() {
          public Object evaluate(String parsedValue) {
            return parsedValue;
          }
        };

    // when
    Object s =
        TextParseUtil.translateVariables('$', "foo: ${foo}", stack, String.class, evaluator, 2);

    // then
    assertEquals("foo: ", s);
  }
Esempio n. 7
0
  public void testTranslateVariables() {
    ValueStack stack = ActionContext.getContext().getValueStack();

    Object s = TextParseUtil.translateVariables("foo: ${{1, 2, 3}}, bar: %{1}", stack);
    assertEquals("foo: [1, 2, 3], bar: 1", s);

    s = TextParseUtil.translateVariables("foo: %{{1, 2, 3}}, bar: %{1}", stack);
    assertEquals("foo: [1, 2, 3], bar: 1", s);

    s = TextParseUtil.translateVariables("foo: %{{1, 2, 3}}, bar: %{1}", stack);
    assertEquals("foo: [1, 2, 3], bar: 1", s);

    s = TextParseUtil.translateVariables("foo: ${#{1 : 2, 3 : 4}}, bar: ${1}", stack);
    assertEquals("foo: {1=2, 3=4}, bar: 1", s);

    s = TextParseUtil.translateVariables("foo: %{#{1 : 2, 3 : 4}}, bar: %{1}", stack);
    assertEquals("foo: {1=2, 3=4}, bar: 1", s);

    s = TextParseUtil.translateVariables("foo: 1}", stack);
    assertEquals("foo: 1}", s);

    s = TextParseUtil.translateVariables("foo: {1}", stack);
    assertEquals("foo: {1}", s);

    s = TextParseUtil.translateVariables("foo: ${1", stack);
    assertEquals("foo: ${1", s);

    s = TextParseUtil.translateVariables("foo: %{1", stack);
    assertEquals("foo: %{1", s);

    s = TextParseUtil.translateVariables('$', "${{1, 2, 3}}", stack, Object.class);
    assertNotNull(s);
    assertTrue("List not returned when parsing a 'pure' list", s instanceof List);
    assertEquals(((List) s).size(), 3);

    s =
        TextParseUtil.translateVariables(
            '$', "${#{'key1':'value1','key2':'value2','key3':'value3'}}", stack, Object.class);
    assertNotNull(s);
    assertTrue("Map not returned when parsing a 'pure' map", s instanceof Map);
    assertEquals(((Map) s).size(), 3);

    s = TextParseUtil.translateVariables('$', "${1} two ${3}", stack, Object.class);
    assertEquals("1 two 3", s);

    s =
        TextParseUtil.translateVariables(
            '$',
            "count must be between ${123} and ${456}, current value is ${98765}.",
            stack,
            Object.class);
    assertEquals("count must be between 123 and 456, current value is 98765.", s);
  }
Esempio n. 8
0
  public void testTranslateNoVariables() {
    ValueStack stack = ActionContext.getContext().getValueStack();

    Object s = TextParseUtil.translateVariables('$', "foo: ${}", stack);
    assertEquals("foo: ", s);
  }
Esempio n. 9
0
 public void testCommaDelimitedStringToSet() {
   assertEquals(0, TextParseUtil.commaDelimitedStringToSet("").size());
   assertEquals(
       new HashSet<String>(Arrays.asList("foo", "bar", "tee")),
       TextParseUtil.commaDelimitedStringToSet(" foo, bar,tee"));
 }