| /** |
| * Copyright (c) 2009, 2018 Obeo and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| * Axel Uhl (SAP AG) - Bug 342644 |
| */ |
| package org.eclipse.ocl.tests; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.emf.ecore.EObject; |
| |
| // FIXME we're missing oclIsNew and oclIsInState |
| /** |
| * This unit test focuses on the Standard library's String operations. |
| * |
| * @author Laurent Goubet (lgoubet) |
| */ |
| @SuppressWarnings("nls") |
| public abstract class GenericEvaluationStringOperationTest<E extends EObject, PK extends E, T extends E, C extends T, CLS extends C, DT extends C, PT extends C, ET extends DT, O extends E, PM extends E, P extends E, PA extends P, PR extends P, EL, S, COA, SSA, CT> |
| extends GenericEvaluationTestSuite<E, PK, T, C, CLS, DT, PT, ET, O, PM, P, PA, PR, EL, S, COA, SSA, CT> { |
| |
| public void testStringAt() { |
| assertResult("t", "'test'.at(1)"); |
| assertResult("e", "'test'.at(2)"); |
| assertResult("t", "'test'.at(4)"); |
| // out of bounds |
| assertResultInvalid("'test'.at(0)"); |
| assertResultInvalid("'test'.at(5)"); |
| assertResultInvalid("''.at(1)"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.at(1)"); |
| // null |
| assertResultInvalid("let s : String = null in s.at(1)"); |
| } |
| |
| private List<String> buildString(String... strings) { |
| List<String> result = new ArrayList<String>(); |
| for (String s : strings) { |
| for (int i = 0; i < s.length(); i++) { |
| result.add(s.substring(i, i+1)); |
| } |
| } |
| return result; |
| } |
| |
| |
| public void testStringCharacters() { |
| assertResult(buildString(), "''.characters()"); |
| assertResult(buildString("a"), "'a'.characters()"); |
| assertResult(buildString("a", "\r", "\n", "b"), "'a\\r\\nb'.characters()"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.characters()"); |
| // null |
| assertResultInvalid("let s : String = null in s.characters()"); |
| } |
| |
| public void testStringConcat() { |
| assertResult("concatenationTest", "'concatenation'.concat('Test')"); |
| // according to 9.3.20, StringLiteralExpCS, '\' 'n' is the escape for a life feed LF |
| assertResult("concatenation\n", "'concatenation'.concat('\\n')"); |
| assertResult("concatenationTest", "'concatenation' + 'Test'"); |
| // according to 9.3.20, StringLiteralExpCS, '\' 'n' is the escape for a life feed LF |
| assertResult("concatenation\n", "'concatenation' + '\\n'"); |
| } |
| |
| public void testStringConcatInvalid() { |
| assertResultInvalid("let s : String = invalid in 'concatenation'.concat(s)"); |
| assertResultInvalid("let s : String = invalid in s.concat('concatenation')"); |
| assertResultInvalid("let s : String = invalid in 'concatenation' + s"); |
| assertResultInvalid("let s : String = invalid in s + 'concatenation'"); |
| } |
| |
| public void testStringConcatNull() { |
| assertResultInvalid("let s : String = null in 'concatenation'.concat(s)"); |
| assertResultInvalid("let s : String = null in s.concat('concatenation')"); |
| assertResultInvalid("let s : String = null in 'concatenation' + s"); |
| assertResultInvalid("let s : String = null in s + 'concatenation'"); |
| } |
| |
| public void testStringEndsWith() { |
| assertResultFalse("'abcdef'.endsWith('aabcdef')"); |
| assertResultTrue("'abcdef'.endsWith('abcdef')"); |
| assertResultTrue("'abcdef'.endsWith('cdef')"); |
| assertResultTrue("'abcdef'.endsWith('f')"); |
| assertResultTrue("'abcdef'.endsWith('')"); |
| assertResultTrue("''.endsWith('')"); |
| assertResultFalse("''.endsWith('a')"); |
| assertResultTrue("'abcdef'.endsWith('')"); |
| assertResultFalse("'abcdef'.endsWith('bcd')"); |
| assertResultFalse("'abcdef'.endsWith('ab')"); |
| assertResultFalse("'abcdef'.endsWith('a')"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.endsWith('')"); |
| assertResultInvalid("let s : String = invalid in ''.endsWith(s)"); |
| // null |
| assertResultInvalid("let s : String = null in s.endsWith('')"); |
| assertResultInvalid("let s : String = null in ''.endsWith(s)"); |
| } |
| |
| public void testStringEqual() { |
| assertResultFalse("'test' = 'se'"); |
| assertResultTrue("'test' = 'test'"); |
| } |
| |
| public void testStringEqualInvalid() { |
| assertResultInvalid("let s : String = invalid in s = 'se'"); |
| assertResultInvalid("let s : String = invalid in 'test' = s"); |
| |
| assertResultInvalid("let s1 : String = invalid, s2 : String = invalid in s1 = s2"); |
| } |
| |
| public void testStringEqualNull() { |
| assertResultFalse("let s : String = null in s = 'se'"); |
| assertResultFalse("let s : String = null in 'test' = s"); |
| |
| assertResultTrue("let s1 : String = null, s2 : String = null in s1 = s2"); |
| } |
| |
| public void testStringEqualIgnoresCase() { |
| assertResultFalse("'test'.equalsIgnoreCase('se')"); |
| assertResultTrue("'test'.equalsIgnoreCase('test')"); |
| assertResultTrue("'Test'.equalsIgnoreCase('tEst')"); |
| assertResultTrue("'tesT'.equalsIgnoreCase('teSt')"); |
| assertResultTrue("'TEST'.equalsIgnoreCase('test')"); |
| assertResultTrue("'test'.equalsIgnoreCase('TEST')"); |
| } |
| |
| public void testStringGreaterThan() { |
| assertResultFalse("'3' > '4'"); |
| assertResultFalse("'a' > 'b'"); |
| assertResultFalse("'aardvark' > 'aardvarks'"); |
| |
| assertResultTrue("'3.2' > '3.1'"); |
| assertResultTrue("'a' > 'A'"); |
| assertResultTrue("'aardvark' > 'aardvarK'"); |
| |
| assertResultFalse("'3' > '3'"); |
| assertResultFalse("'a' > 'a'"); |
| assertResultFalse("'aardvark' > 'aardvark'"); |
| } |
| |
| public void testStringGreaterThanInvalid() { |
| assertResultInvalid("let s : String = invalid in s > 'se'"); |
| assertResultInvalid("let s : String = invalid in 'test' > s"); |
| |
| assertResultInvalid("let s1 : String = invalid, s2 : String = invalid in s1 > s2"); |
| } |
| |
| public void testStringGreaterThanNull() { |
| assertResultInvalid("let s : String = null in s > 'se'"); |
| assertResultInvalid("let s : String = null in 'test' > s"); |
| |
| assertResultInvalid("let s1 : String = null, s2 : String = null in s1 > s2"); |
| } |
| |
| public void testStringGreaterThanOrEqual() { |
| assertResultFalse("'3' >= '4'"); |
| assertResultFalse("'a' >= 'b'"); |
| assertResultFalse("'aardvark' >= 'aardvarks'"); |
| |
| assertResultTrue("'3.2' >= '3.1'"); |
| assertResultTrue("'a' >= 'A'"); |
| assertResultTrue("'aardvark' >= 'aardvarK'"); |
| |
| assertResultTrue("'3' >= '3'"); |
| assertResultTrue("'a' >= 'a'"); |
| assertResultTrue("'aardvark' >= 'aardvark'"); |
| } |
| |
| public void testStringGreaterThanOrEqualInvalid() { |
| assertResultInvalid("let s : String = invalid in s >= 'se'"); |
| assertResultInvalid("let s : String = invalid in 'test' >= s"); |
| |
| assertResultInvalid("let s1 : String = invalid, s2 : String = invalid in s1 >= s2"); |
| } |
| |
| public void testStringGreaterThanOrEqualNull() { |
| assertResultInvalid("let s : String = null in s >= 'se'"); |
| assertResultInvalid("let s : String = null in 'test' >= s"); |
| |
| assertResultInvalid("let s1 : String = null, s2 : String = null in s1 >= s2"); |
| } |
| |
| public void testStringIndexOf() { |
| assertResult(1, "'test'.indexOf('t')"); |
| assertResult(1, "'test'.indexOf('te')"); |
| assertResult(2, "'test'.indexOf('es')"); |
| assertResult(3, "'test'.indexOf('st')"); |
| assertResult(5, "'tesla'.indexOf('a')"); |
| // out of bounds |
| assertResult(0, "'test'.indexOf('xyzzy')"); |
| assertResult(0, "'test'.indexOf('est2')"); |
| // empty |
| assertResult(1, "'test'.indexOf('')"); |
| assertResult(1, "''.indexOf('')"); |
| assertResult(0, "''.indexOf('t')"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in 'test'.indexOf(s)"); |
| assertResultInvalid("let s : String = invalid in s.indexOf('s')"); |
| // null |
| assertResultInvalid("let s : String = null in 'test'.indexOf(s)"); |
| assertResultInvalid("let s : String = null in s.indexOf('s')"); |
| } |
| |
| public void testStringLastIndexOf() { |
| assertResult(4, "'test'.lastIndexOf('t')"); |
| assertResult(1, "'test'.lastIndexOf('te')"); |
| assertResult(2, "'test'.lastIndexOf('es')"); |
| assertResult(3, "'test'.lastIndexOf('st')"); |
| assertResult(5, "'tesla'.lastIndexOf('a')"); |
| assertResult(1, "'ates'.lastIndexOf('a')"); |
| // out of bounds |
| assertResult(0, "'test'.lastIndexOf('xyzzy')"); |
| assertResult(0, "'test'.lastIndexOf('est2')"); |
| // empty |
| assertResult(5, "'test'.lastIndexOf('')"); |
| assertResult(1, "''.lastIndexOf('')"); |
| assertResult(0, "''.lastIndexOf('t')"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in 'test'.lastIndexOf(s)"); |
| assertResultInvalid("let s : String = invalid in s.lastIndexOf('s')"); |
| // null |
| assertResultInvalid("let s : String = null in 'test'.lastIndexOf(s)"); |
| assertResultInvalid("let s : String = null in s.lastIndexOf('s')"); |
| } |
| |
| public void testStringLessThan() { |
| /* |
| * FIXME the standard library doesn't define either less than, less than |
| * or equal, greater than or greater than or equal. Neither should then |
| * compile. If we do define these, why not define them for boolean? |
| */ |
| assertResultTrue("'3' < '4'"); |
| assertResultTrue("'a' < 'b'"); |
| assertResultTrue("'aardvark' < 'aardvarks'"); |
| |
| assertResultFalse("'3.2' < '3.1'"); |
| assertResultFalse("'a' < 'A'"); |
| assertResultFalse("'aardvark' < 'aardvarK'"); |
| |
| assertResultFalse("'3' < '3'"); |
| assertResultFalse("'a' < 'a'"); |
| assertResultFalse("'aardvark' < 'aardvark'"); |
| } |
| |
| public void testStringLessThanInvalid() { |
| assertResultInvalid("let s : String = invalid in s < 'se'"); |
| assertResultInvalid("let s : String = invalid in 'test' < s"); |
| |
| assertResultInvalid("let s1 : String = invalid, s2 : String = invalid in s1 < s2"); |
| } |
| |
| public void testStringLessThanNull() { |
| assertResultInvalid("let s : String = null in s < 'se'"); |
| assertResultInvalid("let s : String = null in 'test' < s"); |
| |
| assertResultInvalid("let s1 : String = null, s2 : String = null in s1 < s2"); |
| } |
| |
| public void testStringLessThanOrEqual() { |
| assertResultTrue("'3' <= '4'"); |
| assertResultTrue("'a' <= 'b'"); |
| assertResultTrue("'aardvark' <= 'aardvarks'"); |
| |
| assertResultFalse("'3.2' <= '3.1'"); |
| assertResultFalse("'a' <= 'A'"); |
| assertResultFalse("'aardvark' <= 'aardvarK'"); |
| |
| assertResultTrue("'3' <= '3'"); |
| assertResultTrue("'a' <= 'a'"); |
| assertResultTrue("'aardvark' <= 'aardvark'"); |
| } |
| |
| public void testStringLessThanOrEqualInvalid() { |
| assertResultInvalid("let s : String = invalid in s <= 'se'"); |
| assertResultInvalid("let s : String = invalid in 'test' <= s"); |
| |
| assertResultInvalid("let s1 : String = invalid, s2 : String = invalid in s1 <= s2"); |
| } |
| |
| public void testStringLessThanOrEqualNull() { |
| assertResultInvalid("let s : String = null in s <= 'se'"); |
| assertResultInvalid("let s : String = null in 'test' <= s"); |
| |
| assertResultInvalid("let s1 : String = null, s2 : String = null in s1 <= s2"); |
| } |
| |
| public void testStringMatches() { |
| assertResultTrue("'characters and spaces'.matches('[\\\\w\\\\s]+')"); // *2 for Java, *2 for OCL |
| assertResultFalse("'characters and 3 digits'.matches('[\\\\p{Alpha}\\\\s]+')"); |
| // |
| assertResultTrue("''.matches('')"); |
| assertResultTrue("''.matches('')"); |
| assertResultFalse("'a'.matches('')"); |
| assertResultFalse("''.matches('b')"); |
| // |
| assertResultInvalid("'repla ce operation'.matches('a[b-')"); //, null, PatternSyntaxException.class); |
| // |
| assertResultInvalid("null.matches('(\\\\w+)\\\\s*')"); |
| assertResultInvalid("'repla ce operation'.matches(null)"); |
| // |
| assertResultInvalid("invalid.matches('(\\\\w+)\\\\s*')"); |
| assertResultInvalid("'repla ce operation'.matches(invalid)"); |
| // -- visual inspection of println's demonstrates cache re-use; this test just conforms cache still ok once full |
| assertQueryEquals(null, 50, "let seq : Sequence(Integer) = Sequence{1..20}, rseq : Sequence(Integer) = seq->collect(i | 21-i), seqs : Sequence(Integer) = Sequence{seq,rseq,seq,rseq,seq}->flatten() in seqs->iterate(i; acc : Integer = 0 | if '123456789'.matches('.*' + i.toString() + '.*') then acc + 1 else acc endif)"); |
| } |
| |
| public void testStringNotEqual() { |
| assertResultTrue("'test' <> 'se'"); |
| assertResultFalse("'test' <> 'test'"); |
| } |
| |
| public void testStringNotEqualInvalid() { |
| assertResultInvalid("let s : String = invalid in s <> 'se'"); |
| assertResultInvalid("let s : String = invalid in 'test' <> s"); |
| |
| assertResultInvalid("let s1 : String = invalid, s2 : String = invalid in s1 <> s2"); |
| } |
| |
| public void testStringNotEqualNull() { |
| assertResultTrue("let s : String = null in s <> 'se'"); |
| assertResultTrue("let s : String = null in 'test' <> s"); |
| |
| assertResultFalse("let s1 : String = null, s2 : String = null in s1 <> s2"); |
| } |
| |
| public void testStringOclAsType() { |
| assertResultInvalid("'test'.oclAsType(Integer)"); |
| assertResult("test", "'test'.oclAsType(String)"); |
| assertResult("test", "'test'.oclAsType(OclAny)"); |
| assertResultInvalid("'test'.oclAsType(OclVoid)"); |
| assertResultInvalid("'test'.oclAsType(OclInvalid)"); |
| } |
| |
| public void testStringOclIsInvalid() { |
| assertResultFalse("'test'.oclIsInvalid()"); |
| assertResultFalse("''.oclIsInvalid()"); |
| } |
| |
| public void testStringOclIsUndefined() { |
| assertResultFalse("'test'.oclIsUndefined()"); |
| assertResultFalse("''.oclIsUndefined()"); |
| } |
| |
| public void testStringPlus() { |
| assertResult("concatenationTest", "'concatenation' + 'Test'"); |
| assertResult("concatenation\n", "'concatenation' + '\\n'"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in 'concatenation' + s"); |
| assertResultInvalid("let s : String = invalid in s + 'concatenation'"); |
| // null |
| assertResultInvalid("let s : String = null in 'concatenation' + s"); |
| assertResultInvalid("let s : String = null in s + 'concatenation'"); |
| // EString |
| assertResult("ab", "let s1 : String = 'a', s2 : String = 'b' in s1 + s2"); |
| assertResult("ab", "let s1 : EString = 'a', s2 : String = 'b' in s1 + s2"); |
| assertResult("ab", "let s1 : String = 'a', s2 : EString = 'b' in s1 + s2"); |
| assertResult("ab", "let s1 : EString = 'a', s2 : EString = 'b' in s1 + s2"); |
| } |
| |
| public void testStringReplaceAll() { |
| assertResult("rePlaceAll oPeration", "'replaceAll operation'.replaceAll('p', 'P')"); |
| assertResult("ReplaceAllOperation", "'Repla ce All Operation'.replaceAll('(\\\\w+)\\\\s*', '$1')"); |
| // |
| assertResult("xx", "''.replaceAll('', 'xx')"); |
| assertResult("xxrxxexxpxxlxxaxx xxcxxexx xxoxxpxxexxrxxaxxtxxixxoxxnxx", "'repla ce operation'.replaceAll('', 'xx')"); |
| assertResult("", "'repla ce operation'.replaceAll('(\\\\w+)\\\\s*', '')"); |
| assertResult("repla ce operation", "'repla ce operation'.replaceAll('', '')"); |
| // |
| assertResultInvalid("'repla ce operation'.replaceAll('a[b-', '$1')"); //, null, PatternSyntaxException.class); |
| assertResultInvalid("'repla ce operation'.replaceAll('', '$1')"); //, "No group 1", IndexOutOfBoundsException.class); |
| // |
| // assertResultInvalid("null.replaceAll('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceAll(null, '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceAll('(\\\\w+)\\\\s*', null)"); |
| // |
| // assertResultInvalid("invalid.replaceAll('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceAll(invalid, '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceAll('(\\\\w+)\\\\s*', invalid)"); |
| } |
| |
| public void testStringReplaceFirst() { |
| assertResult("rePlace operation", "'replace operation'.replaceFirst('p', 'P')"); |
| assertResult("replace operation", "'repla ce operation'.replaceFirst('(\\\\w+)\\\\s*', '$1')"); |
| // |
| assertResult("xx", "''.replaceFirst('', 'xx')"); |
| assertResult("xxrepla ce operation", "'repla ce operation'.replaceFirst('', 'xx')"); |
| assertResult("ce operation", "'repla ce operation'.replaceFirst('(\\\\w+)\\\\s*', '')"); |
| assertResult("repla ce operation", "'repla ce operation'.replaceFirst('', '')"); |
| // |
| assertResultInvalid("'repla ce operation'.replaceFirst('a[b-', '$1')"); //, null, PatternSyntaxException.class); |
| assertResultInvalid("'repla ce operation'.replaceFirst('', '$1')"); //, "No group 1", IndexOutOfBoundsException.class); |
| // |
| // assertResultInvalid("null.replaceFirst('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceFirst(null, '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceFirst('(\\\\w+)\\\\s*', null)"); |
| // |
| // assertResultInvalid("invalid.replaceFirst('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceFirst(invalid, '$1')"); |
| assertResultInvalid("'repla ce operation'.replaceFirst('(\\\\w+)\\\\s*', invalid)"); |
| } |
| |
| public void testStringSize() { |
| assertResult(Integer.valueOf(4), "'test'.size()"); //$NON-NLS-2$ |
| assertResult(Integer.valueOf(0), "''.size()"); //$NON-NLS-2$ |
| } |
| |
| public void testStringSizeInvalid() { |
| assertResultInvalid("let s : String = invalid in s.size()"); //$NON-NLS-2$ |
| } |
| |
| public void testStringSizeNull() { |
| assertResultInvalid("let s : String = null in s.size()"); //$NON-NLS-2$ |
| } |
| |
| public void testStringStartsWith() { |
| assertResultFalse("'abcdef'.startsWith('abcdefg')"); |
| assertResultTrue("'abcdef'.startsWith('abcdef')"); |
| assertResultTrue("'abcdef'.startsWith('abcd')"); |
| assertResultTrue("'abcdef'.startsWith('a')"); |
| assertResultTrue("'abcdef'.startsWith('')"); |
| assertResultTrue("''.startsWith('')"); |
| assertResultFalse("''.startsWith('a')"); |
| assertResultTrue("'abcdef'.startsWith('')"); |
| assertResultFalse("'abcdef'.startsWith('bcd')"); |
| assertResultFalse("'abcdef'.startsWith('ef')"); |
| assertResultFalse("'abcdef'.startsWith('f')"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.startsWith('')"); |
| assertResultInvalid("let s : String = invalid in ''.startsWith(s)"); |
| // null |
| assertResultInvalid("let s : String = null in s.startsWith('')"); |
| assertResultInvalid("let s : String = null in ''.startsWith(s)"); |
| } |
| |
| public void testStringSubstituteAll() { |
| assertResult("subsTiTuTeAll operaTion", "'substituteAll operation'.substituteAll('t', 'T')"); |
| // |
| assertResult("xx", "''.replaceAll('', 'xx')"); |
| assertResult("xxrxxexxpxxlxxaxx xxcxxexx xxoxxpxxexxrxxaxxtxxixxoxxnxx", "'repla ce operation'.substituteAll('', 'xx')"); |
| assertResult("repla ce operation", "'repla ce operation'.substituteAll('(\\\\w+)\\\\s*', '')"); |
| assertResult("repla ce operation", "'repla ce operation'.substituteAll('', '')"); |
| // |
| // assertResultInvalid("null.substituteAll('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteAll(null, '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteAll('(\\\\w+)\\\\s*', null)"); |
| // |
| // assertResultInvalid("invalid.substituteAll('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteAll(invalid, '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteAll('(\\\\w+)\\\\s*', invalid)"); |
| } |
| |
| public void testStringSubstituteFirst() { |
| assertResult("subsTiTuTeFirst operaTion", "'substiTuTeFirst operaTion'.substituteFirst('t', 'T')"); |
| assertResult("SubstiTuTeFirst operaTion", "'substiTuTeFirst operaTion'.substituteFirst('s', 'S')"); |
| assertResult("substiTuTeFirst operaTioN", "'substiTuTeFirst operaTion'.substituteFirst('n', 'N')"); |
| assertResult("substiTuTeFirst operaTion", "'substiTuTeFirst operaTion'.substituteFirst('n', 'n')"); |
| assertResult("substiTuTeFirst operaTiON", "'substiTuTeFirst operaTion'.substituteFirst('on', 'ON')"); |
| assertResult("a[b-c]d\r\n*", "'a[b-c]d\\\\w*'.substituteFirst('\\\\w', '\\r\\n')"); |
| // |
| assertResult("xx", "''.substituteFirst('', 'xx')"); |
| assertResult("xxrepla ce operation", "'repla ce operation'.substituteFirst('', 'xx')"); |
| assertResult("repla ce operation", "'repla ce operation'.substituteFirst('', '')"); |
| // |
| assertResultInvalid("'repla ce operation'.substituteFirst('(\\\\w+)\\\\s*', '')"); //, |
| // DomainUtil.bind(EvaluatorMessages.MissingSubstring, "(\\w+)\\s*", "repla ce operation"), null); |
| // |
| // assertResultInvalid("null.substituteFirst('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteFirst(null, '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteFirst('(\\\\w+)\\\\s*', null)"); |
| // |
| // assertResultInvalid("invalid.substituteFirst('(\\\\w+)\\\\s*', '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteFirst(invalid, '$1')"); |
| assertResultInvalid("'repla ce operation'.substituteFirst('(\\\\w+)\\\\s*', invalid)"); |
| } |
| |
| public void testStringSubstring() { |
| assertResult("t", "'test'.substring(1, 1)"); |
| assertResult("es", "'test'.substring(2, 3)"); |
| assertResult("t", "'test'.substring(4, 4)"); |
| } |
| |
| public void testStringSubstringIllegalArguments() { |
| /* |
| * FIXME in OCL, substring(2, 1) is the equivalent of java's |
| * substring(1,1) : an empty String. However this really looks like it |
| * should fail. |
| */ |
| assertResultInvalid("'test'.substring(2, 1)"); |
| assertResultInvalid("'test'.substring(3, 1)"); |
| } |
| |
| public void testStringSubstringInvalid() { |
| assertResultInvalid("let s : String = invalid in s.substring(1, 1)"); |
| assertResultInvalid("let s : String = invalid in s.substring(5, 5)"); |
| } |
| |
| public void testStringSubstringNull() { |
| assertResultInvalid("let s : String = null in s.substring(1, 1)"); |
| assertResultInvalid("let s : String = null in s.substring(5, 5)"); |
| } |
| |
| public void testStringSubstringOutOfBounds() { |
| assertResultInvalid("'test'.substring(0, 1)"); |
| assertResultInvalid("'test'.substring(4, 5)"); |
| } |
| |
| public void testStringToBoolean() { |
| assertResultTrue("'true'.toBoolean()"); |
| assertResultFalse("' true'.toBoolean()"); |
| assertResultFalse("'true '.toBoolean()"); |
| assertResultFalse("'True'.toBoolean()"); |
| assertResultFalse("'false'.toBoolean()"); |
| assertResultFalse("'-4'.toBoolean()"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.toBoolean()"); |
| // null |
| assertResultInvalid("let s : String = null in s.toBoolean()"); |
| } |
| |
| public void testStringToInteger() { |
| assertResult(Integer.valueOf(4), "'4'.toInteger()"); |
| assertResult(Integer.valueOf(-4), "'-4'.toInteger()"); |
| assertResultInvalid("'4.0'.toInteger()"); |
| |
| assertResultInvalid("'2.4.0'.toInteger()"); |
| assertResultInvalid("'a'.toInteger()"); |
| } |
| |
| public void testStringToIntegerInvalid() { |
| assertResultInvalid("let s : String = invalid in s.toInteger()"); |
| } |
| |
| public void testStringToIntegerNull() { |
| assertResultInvalid("let s : String = null in s.toInteger()"); |
| } |
| |
| public void testStringToLower() { |
| checkForUTF8Encoding(); |
| assertResult("4", "'4'.toLower()"); //$NON-NLS-2$ |
| assertResult("mixed", "'MiXeD'.toLower()"); //$NON-NLS-2$ |
| assertResult("upper", "'UPPER'.toLower()"); //$NON-NLS-2$ |
| // Ensures word-final sigma and regular sigmas are converted as needed |
| // TODO re-enable once the Unicode problems on Hudson have been resolved |
| // assertResult( |
| // "ὀδυσσεύς", "'ὈΔΥΣΣΕΎΣ'.toLower()"); |
| } |
| |
| public void testStringToLowerCase() { |
| checkForUTF8Encoding(); |
| assertResult("4", "'4'.toLowerCase()"); //$NON-NLS-2$ |
| assertResult("mixed", "'MiXeD'.toLowerCase()"); //$NON-NLS-2$ |
| assertResult("upper", "'UPPER'.toLowerCase()"); //$NON-NLS-2$ |
| // Ensures word-final sigma and regular sigmas are converted as needed |
| // TODO re-enable once the Unicode problems on Hudson have been resolved |
| // assertResult( |
| // "ὀδυσσεύς", "'ὈΔΥΣΣΕΎΣ'.toLowerCase()"); |
| } |
| |
| public void testStringToLowerInvalid() { |
| assertResultInvalid("let s : String = invalid in s.toLower()"); |
| } |
| |
| public void testStringToLowerNull() { |
| assertResultInvalid("let s : String = null in s.toLower()"); |
| } |
| |
| public void testStringToReal() { |
| assertResult(Double.valueOf(4d), "'4'.toReal()"); |
| assertResult(Double.valueOf(-4d), "'-4'.toReal()"); |
| assertResult(Double.valueOf(4d), "'4.0'.toReal()"); |
| |
| assertResultInvalid("'2.4.0'.toReal()"); |
| assertResultInvalid("'a'.toReal()"); |
| } |
| |
| public void testStringToRealInvalid() { |
| assertResultInvalid("let s : String = invalid in s.toReal()"); |
| } |
| |
| public void testStringToRealNull() { |
| assertResultInvalid("let s : String = null in s.toReal()"); |
| } |
| |
| public void testStringToString() { |
| assertExpressionResults("'4.0'", "'4.0'.toString()"); |
| // assertResult("'4.0\t4'", "('4.0' + '\t' + '4').toString()"); |
| assertResult("4.0 4", "('4.0' + ' ' + '4').toString()"); |
| } |
| |
| public void testStringToUpper() { |
| checkForUTF8Encoding(); |
| assertResult("4", "'4'.toUpper()"); |
| assertResult("MIXED", "'MiXeD'.toUpper()"); |
| assertResult("LOWER", "'lower'.toUpper()"); |
| |
| // Ensures word-final sigma and regular sigmas are converted as needed |
| // TODO re-enable once the Unicode problems on Hudson have been resolved |
| // assertResult("ὈΔΥΣΣΕΎΣ", "'ὀδυσσεύς'.toUpper()"); |
| |
| // Sharp s should be mapped to a double S upper case |
| // TODO re-enable once the Unicode problems on Hudson have been resolved |
| // assertResult("SS", "'ß'.toUpper()"); |
| } |
| |
| public void testStringToUpperCase() { |
| checkForUTF8Encoding(); |
| assertResult("4", "'4'.toUpperCase()"); |
| assertResult("MIXED", "'MiXeD'.toUpperCase()"); |
| assertResult("LOWER", "'lower'.toUpperCase()"); |
| |
| // Ensures word-final sigma and regular sigmas are converted as needed |
| // TODO re-enable once the Unicode problems on Hudson have been resolved |
| // assertResult("ὈΔΥΣΣΕΎΣ", "'ὀδυσσεύς'.toUpperCase()"); |
| |
| // Sharp s should be mapped to a double S upper case |
| // TODO re-enable once the Unicode problems on Hudson have been resolved |
| // assertResult("SS", "'ß'.toUpperCase()"); |
| } |
| |
| public void testStringToUpperInvalid() { |
| assertResultInvalid("let s : String = invalid in s.toUpper()"); |
| } |
| |
| public void testStringToUpperNull() { |
| assertResultInvalid("let s : String = null in s.toUpper()"); |
| } |
| |
| public void testStringTokenize() { |
| // assertExpressionResults("Sequence{'', 'a','b','c','d', ''}", "'\\na b\\tc\\fd\\r'.tokenize()"); |
| assertExpressionResults("Sequence{'a','b','c','d'}", "'\\na b\\tc\\fd\\r'.tokenize()"); |
| assertExpressionResults("Sequence{'a','b','c','d'}", "' \\t\\n\\r\\fa b\\tc\\fd \\t\\n\\r\\f'.tokenize()"); |
| assertExpressionResults("Sequence{' ','\\t','\\n','\\r','\\f','a',' ','b','\\t','c','\\f','d',' ','\\t','\\n','\\r','\\f'}", "' \\t\\n\\r\\fa b\\tc\\fd \\t\\n\\r\\f'.tokenize(' \\t\\n\\r\\f', true)"); |
| assertExpressionResults("Sequence{'\\na',' ', 'b\\tc\\fd\\r'}", "'\\na b\\tc\\fd\\r'.tokenize(' ', true)"); |
| assertExpressionResults("Sequence{}", "''.tokenize(' ', true)"); |
| assertExpressionResults("Sequence{' \\t\\n\\r\\f'}", "' \\t\\n\\r\\f'.tokenize('', true)"); |
| assertExpressionResults("Sequence{}", "''.tokenize('', true)"); |
| assertExpressionResults("Sequence{}", "''.tokenize(' \\t\\n\\r\\f', true)"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.tokenize()"); |
| assertResultInvalid("let s : String = invalid in s.tokenize('')"); |
| assertResultInvalid("let s : String = invalid in s.tokenize('',true)"); |
| assertResultInvalid("let s : String = invalid in ''.tokenize(s)"); |
| assertResultInvalid("let s : String = invalid in ''.tokenize(s,true)"); |
| assertResultInvalid("let b : Boolean = invalid in ''.tokenize('',b)"); |
| // null |
| assertResultInvalid("let s : String = null in s.tokenize()"); |
| assertResultInvalid("let s : String = null in s.tokenize('')"); |
| assertResultInvalid("let s : String = null in s.tokenize('',true)"); |
| assertResultInvalid("let s : String = null in ''.tokenize(s)"); |
| assertResultInvalid("let s : String = null in ''.tokenize(s,true)"); |
| assertResultInvalid("let b : Boolean = null in ''.tokenize('',b)"); |
| // |
| // assertSemanticErrorQuery("''.tokenize('',false,null)", OCLMessages.UnresolvedOperationCall_ERROR_, "tokenize", "String", "String, Boolean, OclVoid"); |
| } |
| |
| public void testStringTrim() { |
| assertResult("ab", "'ab'.trim()"); |
| assertResult("a", "'a'.trim()"); |
| assertResult("", "''.trim()"); |
| assertResult("a \t\n\r\fb", "'\\na \\t\\n\\r\\fb\\n'.trim()"); |
| assertResult("", "' \\t\\n\\r\\f \\t\\n\\r\\f'.trim()"); |
| // invalid |
| assertResultInvalid("let s : String = invalid in s.trim()"); |
| // null |
| assertResultInvalid("let s : String = null in s.trim()"); |
| } |
| } |
