alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Groovy example source code file (GStringTest.groovy)

This example Groovy source code file (GStringTest.groovy) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Groovy tags/keywords

bar, bob, bob, gromit, groovyruntimeexception, groovyruntimeexception, groovytestcase, gstring, hello, string, string, stringwriter, stringwriter, the

The Groovy GStringTest.groovy source code

/*
 * Copyright 2003-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package groovy

class GStringTest extends GroovyTestCase {

    void check(template, teststr) {
        assert template instanceof GString

        def count = template.getValueCount()
        assert count == 1
        assert template.getValue(0) == "Bob"

        def string = template.toString()
        assert string == teststr
    }

    void testEmptyGString() {
        def foo = 'Foo'
        def bar = 'Bar'
        def g = GString.EMPTY + "$foo".toString() + "$bar"
        assert g instanceof GString
        assert g.values == ['Bar']
        assert 'FooBar' == g
    }

    void testWithOneVariable() {
        def name = "Bob"
        def teststr = "hello Bob how are you?"

        check("hello $name how are you?", teststr)
        check("hello ${name} how are you?", teststr)
        check("hello ${println "feep"; name} how are you?", teststr)
        check(/hello $name how are you?/, teststr)
        check(/hello ${name} how are you?/, teststr)
        check(/hello ${println "feep"; name} how are you?/, teststr)
    }

    void testWithVariableAtEnd() {
        def name = "Bob"
        def teststr = "hello Bob"

        check("hello $name", teststr)
        check("hello ${name}", teststr)
        check(/hello $name/, teststr)
        check(/hello ${name}/, teststr)
    }

    void testWithVariableAtBeginning() {
        def name = "Bob"
        def teststr = "Bob hey"
        check("$name hey", teststr)
        check("${name} hey", teststr)
        name = ""
        check("${name += "Bob"; name} hey", teststr)
        assert name == "Bob"
        check(/$name hey/, teststr)
        check(/${name} hey/, teststr)
        name = ""
        check(/${name += "Bob"; name} hey/, teststr)
    }

    void testWithJustVariable() {
        def teststr
        def name = teststr = "Bob"
        check("$name", teststr)
        check("${name}", teststr)
        check("${assert name == "Bob"; name}", teststr)
        // Put punctuation after the variable name:
        check("$name.", "Bob.")
        check("$name...", "Bob...")
        check("$name?", "Bob?")

        check(/$name/, teststr)
        check(/${name}/, teststr)
        check(/${assert name == "Bob"; name}/, teststr)
        // Put punctuation after the variable name:
        check(/$name./, "Bob.")
        check(/$name.../, "Bob...")
        check(/$name?/, "Bob?")
        check(/$name\?/, "Bob\\?")
        check(/$name$/, "Bob\$")

        def guy = [name: name]
        check("${guy.name}", "Bob")
        check("$guy.name", "Bob")
        check("$guy.name.", "Bob.")
        check("$guy.name...", "Bob...")
        check("$guy.name?", "Bob?")
        check(/$guy.name/, "Bob")
        check(/$guy.name./, "Bob.")
        check(/$guy.name.../, "Bob...")
        check(/$guy.name?/, "Bob?")
        check(/$guy.name\?/, "Bob\\?")
        check(/$guy.name$/, "Bob\$")
    }

    void testWithTwoVariables() {
        def name = "Bob"
        def template = "${name}${name}"
        def string = template.toString()

        assert string == "BobBob"
    }

    void testWithTwoVariablesWithSpace() {
        def name = "Bob"
        def template = "${name} ${name}"
        def string = template.toString()

        assert string == "Bob Bob"
    }

    void testAppendString() {
        def a = "dog"
        def b = "a ${a}"
        def c = b + " cat"
        assert c.toString() == "a dog cat", c

        b += " cat"
        assert b.toString() == "a dog cat", b
    }

    void testAppendGString() {
        def a = "dog"
        def b = "a ${a}"
        b += " cat${a}"

        assert b.toString() == "a dog catdog", b
    }

    void testReturnString() {
        def value = dummyMethod()
        assert value == "Hello Gromit!"
    }

    String dummyMethod() {
        def name = "Gromit"
        return "Hello ${name}!"
    }

    void testCoerce() {
        def enc = "US-ASCII"
        def value = "test".getBytes("${enc}")
         assert value == [116, 101, 115, 116]
    }

    void testGroovy441() {
        def arg = "test"
        def content = "${arg} ="
        if (arg != "something") {
            content += "?"
        }
        content += "= ${arg}."
        assert content == "test =?= test."
    }

    void testTwoStringsInMiddle() {
        def a = "---"
        def b = "${a} :"
        b += "<<"
        b += ">>"
        b += ": ${a}"
        assert b == "--- :<<>>: ---"
    }

    void testAlternatingGStrings() {
        def a = "---"
        def b = "${a} :"
        b += "<<"
        b += " [[${a}]] "
        b += ">>"
        b += ": ${a}"
        assert b == "--- :<< [[---]] >>: ---"
    }

     // Test case for GROOVY-599
    void testGStringInStaticMethod() {
        int value = 2
        String str = "1${value}3"
        int result = Integer.parseInt(str)
        assert result == 123
        result = Integer.parseInt("1${value}3")
        assert result == 123
    }

    // Test case for GROOVY-2275
    void testGetAtWithRange() {
        def number = 1234567
        def numberString = "${number}"
        def realString = "1234567"
        assert numberString[0..-1] == '1234567'
        assert realString[0..-1] == '1234567'
    }

    void testEmbeddedClosures() {
        def c1 = {-> "hello"}
        def c2 = {out -> out << "world"}
        def c3 = {a, b -> b << a}
        def c4 = c3.curry(5)

        def g1 = "${-> "hello"} ${out -> out << "world"}"
        def g2 = "$c1 $c2"
        def g3 = "${-> c1} ${-> c2}"
        def g4 = "$c4"
        def g5 = "$c3"

        def w = new StringWriter()
        w << g1
        assertEquals(w.buffer.toString(), "hello world")
        assertEquals(g1.toString(), "hello world")
        w = new StringWriter()
        w << g2
        assertEquals(w.buffer.toString(), "hello world")
        assertEquals(g2.toString(), "hello world")
        w = new StringWriter()
        w << g3
        assert w.buffer.toString().contains("closure")
        assert g3.toString().contains("closure")
        w = new StringWriter()
        w << g4
        assertEquals(w.buffer.toString(), "5")
        assertEquals(g4.toString(), "5")
        try {
            println g5
            fail("should throw a GroovyRuntimeException")
        } catch (GroovyRuntimeException e) {
        }
        try {
            println g5.toString()
            fail("should throw a GroovyRuntimeException")
        } catch (GroovyRuntimeException e) {
        }
    }

    /**
     * Tests comparing two strings which have the same string representation but
     * only one of which uses a template. This is a test for GROOVY-626.
     */
    void testEqualsTemplateToLiteral() {
        def template = "${2}"
        def literal = "2"

        // succeeds
        assertTrue("template == literal false", template == literal)
        assertTrue("literal == template false", literal == template)

        // these fail
        assertFalse("literal not equal to template", literal.equals(template))
        assertFalse("template not equal to literal", template.equals(literal))
        assertTrue("hash codes not equal", literal.hashCode() != template.hashCode())
    }

    /**
     * Tests getting a character by index where the index is a reference instead of a constant.
     * This is a test for GROOVY-1139.
     */
    void testCharAtWithIntegerReference() {
        def literal = "0123456789";
        def template = "${literal}";

        def i = 0
        assertEquals("wrong character at position 0", '0', literal[i]);
        assertEquals("wrong character at position 0", '0', template[i]);

        i = 5
        assertEquals("wrong character at position 5", '5', literal[i]);
        assertEquals("wrong character at position 5", '5', template[i]);

        i = 9
        assertEquals("wrong character at position 9", '9', literal[i]);
        assertEquals("wrong character at position 9", '9', template[i]);
    }

    /**
     * Tests getting a character by index, counting from the beginning of the string.
     */
    void testCharAtFromStart() {
        def literal = "0123456789";
        def template = "${literal}";

        assertEquals("wrong character at position 0", '0', literal[0]);
        assertEquals("wrong character at position 5", '5', literal[5]);
        assertEquals("wrong character at position 9", '9', literal[9]);

        assertEquals("wrong character at position 0", '0', template[0]);
        assertEquals("wrong character at position 5", '5', template[5]);
        assertEquals("wrong character at position 9", '9', template[9]);
    }

    /**
     * Tests getting a character by index, counting from the end of the string.
     */
    void testCharAtFromEnd() {
        def literal = "0123456789";
        def template = "${literal}";

        assertEquals("wrong character at position -1", '9', literal[-1]);
        assertEquals("wrong character at position -5", '5', literal[-5]);
        assertEquals("wrong character at position -10", '0', literal[-10]);

        assertEquals("wrong character at position -1", '9', template[-1]);
        assertEquals("wrong character at position -5", '5', template[-5]);
        assertEquals("wrong character at position -10", '0', template[-10]);
    }

    /**
     * Tests extracting a range which starts at position zero and ends before the
     * end of the string.
     */
    private void doTestExtractRangeStartToBeforeEnd(string) {
        // inclusive
        assertEquals("string[0..-3]", "01234567", string[0..-3]);

        // exclusive
        assertEquals("string[0..<-3]", "0123456", string[0..<-3]);
    }

    /**
     * Tests extracting a range which starts before the end of the string and ends at 0.
     * For an inclusive range, this reverses the string.  For an exclusive range, this
     * counts from the end to the last character.
     */
    void doTestExtractRangeBeforeEndToStart(string) {
        // inclusive
        assertEquals("string[-3..0]", "76543210", string[-3..0]);

        // exclusive
        assertEquals("string[-3..<0]", "7654321", string[-3..<0]);
    }

    /**
     * Calls <code>doTestExtractRangeStartToBeforeEnd with a non-template string.
     *
     * GROOVY-781
     */
    void fixmeTestExtractRangeStartToBeforeEndLiteral() {
        def literal = "0123456789";
        doTestExtractRangeStartToBeforeEnd(literal);
    }

    /**
     * Calls <code>doTestExtractRangeStartToBeforeEnd with a template string.
     *
     * GROOVY-781
     */
    void fixmeTestExtractRangeStartToBeforeEndTemplate() {
        def literal = "0123456789";
        def template = "${literal}";

        doTestExtractRangeStartToBeforeEnd(template);
    }

    /**
     * Calls <code>doTestExtractRangeBeforeEndToStart with a non-template string.
     *
     * GROOVY-781
     */
    void fixmeTestExtractRangeBeforeEndToStartLiteral() {
        def literal = "0123456789";
        doTestExtractRangeBeforeEndToStart(literal);
    }

    /**
     * Calls <code>doTestExtractRangeBeforeEndToStart with a template string.
     *
     * GROOVY-781
     */
    void fixmeTestExtractRangeBeforeEndToStartTemplate() {
        def literal = "0123456789";
        def template = "${literal}";

        doTestExtractRangeBeforeEndToStart(template);
    }

    /**
     * Tests replacing a value in a string with an undefined variable.
     */
    void testReplaceValueWithUndefinedVariable() {
        try {
            def str = "replace <${undefined}>"
            fail("undefined value not detected");
        }
        catch (MissingPropertyException e) {
        }
    }

    /**
     * Tests replacing a value with a null expression.
     */
    void testReplaceValueWithNullExpression() {
        def str = "replace <${null}>";
        assertEquals(str, 'replace <null>');
    }

    /**
     * Tests replacing a value with a compound expression.
     */
    void testReplaceValueWithCompoundExpression() {
        def i = 1, j = 2
        def str = "replace <${i; j}>"
        assertEquals('value replaced', 'replace <2>', str)
    }

    /**
     * Tests incrementing the variable being substituted after creating the string.  This
     * shouldn't have any effect because the string holds a reference to the original value.
     */
    void testIncrementAfterCreatingString() {
        def i = 1
        def str = "replace <${i}> <${i * 2}>"
        assertEquals("value ok", "replace <1> <2>", str)
        i++
        assertEquals("value ok", "replace <1> <2>", str)
    }

    /**
     * Tests evaluating a closure embedded in a string.
     */
    void testClosureInString() {
        def i = 1
        def closure = {i};
        def str = "<${closure()}>"
        assertEquals('closure replacement ok', '<1>', str)

        // this has no effect because the closure is only evaluated once when the string
        // is created
        i++
        assertEquals('closure replacement ok', '<1>', str)
    }

    /**
     * Tests embedding a mutable object in a string.
     */
    void testEmbedMutableObject() {
        def buffer = new StringBuffer("value")
        def stringValue = "value";
        def str = "buffer: <${buffer}>"
        assertEquals("buffer: <value>", str)
    }

    /**
     * Tests modifying a string embedded in another string, which should have no effect.
     */
    void testAppendToEmbeddedStringValue() {
        def stringValue = "value";
        def str = "string: <${stringValue}>"
        assertEquals("string: <value>", str)

        // this has no effect because the string contains a reference stringValue
        // and += for strings creates a new string instead of modifying the existing value.
        stringValue += " more"
        assertEquals("string: <value>", str)
    }

    /**
     * Tests including a map in a string
     */
    void testMapInString() {
        def map = ["key": 1];
        def str = "map.key: <${map.key}>; map: <${map}>";
        assertEquals("map replacement ok", 'map.key: <1>; map: <[key:1]>', str)
        map.key++;

        // The map shows the effects of the change because the string holds a reference
        // to the mutable map.  map.key doesn't show the effect of the change because
        // in this slot the string holds a reference to the original value and
        // map.kep++ created a new value which was stored in the map.
        assertEquals("map replacement ok", 'map.key: <1>; map: <[key:2]>', str)
    }

    /**
     * Tests including a string in itself recursively.
     */
    void testRecursiveReplacement() {
        def str = "1";
        str = "<${str}>";
        assertEquals("recursive string replaced", '<1>', str);
    }

    /**
     * Void method
     */
    void doNothing()
    {
    }

    /**
     * Tests replacing a value with a void statement.
     */
    void testReplaceValueWithVoidStatement() {
        def str = "replace <${doNothing()}>"
        assertEquals('value replaced', 'replace <null>', str)
    }

    /**
     * Tests replacing a value with an empty statement.
     */
    void testReplaceValueWithEmptyStatement() {
        def str = "replace <${;}>"
        assertEquals('value replaced', 'replace <null>', str)
    }

    /**
     * Tests replacing a value with an empty expression.
     */
    void testReplaceValueWithEmptyExpression() {
        assertEquals('replace <null>', "replace <${}>")
    }

    /**
     * Tests GString concatenation. GROOVY-2848
     */
    void testGStringConcatenationAddsNoNewValues() {
        def x = "dog"
        def y = "woof-woof"
        def gs1 = "the ${x} says "
        assert gs1.getValues() == ["dog"]
        assert gs1.toString() == "the dog says "

        gs1 = gs1.plus(" ${y} ")
        assert gs1.getValues() == ["dog", "woof-woof"]
        assert gs1.toString() == "the dog says  woof-woof "

        gs1 = gs1.plus(" not the cat")
        assert gs1.getValues() == ["dog", "woof-woof"]
        assert gs1.toString() == "the dog says  woof-woof  not the cat"
    }

    /**
     * Tests GString splitting. GROOVY-3359
     */
    void testGStringSplitting() {
        def gs = "The quick brown ${'xof'.reverse()}"
        assert gs.split() == ['The', 'quick', 'brown', 'fox'] as String[]
        assert gs.split('o') == ['The quick br', 'wn f', 'x'] as String[]
    }
}

Other Groovy examples (source code examples)

Here is a short list of links related to this Groovy GStringTest.groovy source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.