/*******************************************************************************
* Copyright (c) 2009 Cloudsmith Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Cloudsmith Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.equinox.p2.tests.omniVersion;
import junit.framework.TestCase;
import org.eclipse.equinox.p2.metadata.Version;
/**
* Tests format(s), and format(S)
*
* a string group matching any character except any following
* explicit/optional delimiter. Use processing rules =[]; or =[^] to define the set of allowed characters.
*
*/
public class FormatSTest extends TestCase {
public void testStringAcceptDigit() {
Version v = Version.parseVersion("format(S):1");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'1'"), v);
try {
Version.parseVersion("format(s):1");
fail("Uncaught error: s should not accept digits");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
public void testStringAcceptAlpha() {
Version v = Version.parseVersion("format(s):a");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'a'"), v);
assertNotNull(v = Version.parseVersion("format(S):a"));
assertEquals(Version.parseVersion("raw:'a'"), v);
}
public void testStringDelimitedByNumeric() {
Version v = Version.parseVersion("format(sn):foobar123");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'foobar'.123"), v);
try {
Version.parseVersion("format(Sn):foobar123");
fail("Uncaught error: S should eat entire string, no n found at the end");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
public void testStringWithSpace() {
Version v;
assertNotNull(v = Version.parseVersion("format(S=[^0-9];n):foo bar123"));
assertEquals(Version.parseVersion("raw:'foo bar'.123"), v);
// Test 's' with attempt to include 'space' and delimiters
//
try {
Version.parseVersion("format(s=[^];n):foo bar123");
fail("Uncaught error: format(s) can not match non letters (space).");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
public void testStringDelimitedByDelimiter() {
Version v = Version.parseVersion("format(s.n):foobar.123");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'foobar'.123"), v);
assertNotNull(v = Version.parseVersion("format(S=[^.];.n):foobar.123"));
assertEquals(Version.parseVersion("raw:'foobar'.123"), v);
}
public void testStringDelimitedByExplicitDelimiter() {
Version v = Version.parseVersion("format(s=[^r];d=[r];n):foobar123");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'fooba'.123"), v);
}
public void testStringWithAllowedSet() {
Version v = Version.parseVersion("format(s=[a-z];sn):fooBAR123");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'foo'.'BAR'.123"), v);
}
public void testStringWithDisallowedSet() {
Version v = Version.parseVersion("format(s=[^a-z];sn):FOObar123");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'FOO'.'bar'.123"), v);
}
public void testExact() {
Version v = Version.parseVersion("format(S={4};S):123abc456'def'");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'123a'.\"bc456'def'\""), v);
assertNotNull(v = Version.parseVersion("format(s={2};s):abc"));
assertEquals(Version.parseVersion("raw:'ab'.'c'"), v);
assertNotNull(v = Version.parseVersion("format(S={2};S):abc"));
assertEquals(Version.parseVersion("raw:'ab'.'c'"), v);
assertNotNull(v = Version.parseVersion("format(S={2};S):123"));
assertEquals(Version.parseVersion("raw:'12'.'3'"), v);
assertNotNull(v = Version.parseVersion("format(S={4};S={1};S={3};):123abc45"));
assertEquals(Version.parseVersion("raw:'123a'.'b'.'c45'"), v);
assertNotNull(v = Version.parseVersion("format(S={2};.S={1};s={3};):12.3abc"));
assertEquals(Version.parseVersion("raw:'12'.'3'.'abc'"), v);
try {
Version.parseVersion("format(s={4};.s):aaa.abc456'def'");
fail("Uncaught error: first segment is less than 4 chars long");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
Version.parseVersion("format(s={4};.s):123.abc456'def'");
fail("Uncaught error: first segment has digits");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
Version.parseVersion("format(S={4}=[^.];.S):123.abc456'def'");
fail("Uncaught error: first segment has only 3 characters");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
/**
* Test that unbound upper range is just a limit on lower range. Upper delimiter must be a delimiter.
*/
public void testAtLeast() {
Version v = Version.parseVersion("format(S={2,};):123abc456'def'");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:\"123abc456'def'\""), v);
assertNotNull(v = Version.parseVersion("format(S={2,};=[^.];.S):123a.bc456'def'"));
assertEquals(Version.parseVersion("raw:'123a'.\"bc456'def'\""), v);
try {
Version.parseVersion("format(s={2,};.S):a.abc456'def'");
fail("uncaught error: first segment is shorter than 2");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
Version.parseVersion("format(s={2,};.s={10,};):aa.abcd");
fail("Uncaught error: secont segment too short");
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
public void testAtMost() {
Version v = Version.parseVersion("format(S={1,3};S={1,2};S):123abc456'def'");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'123'.'ab'.\"c456'def'\""), v);
// delimited by delimiter
assertNotNull(v = Version.parseVersion("format(S={1,4};=[^.];.S={1,4};.S):123.abc4.56'def'"));
assertEquals(Version.parseVersion("raw:'123'.'abc4'.\"56'def'\""), v);
try {
// fails because of delimiter after one char
Version.parseVersion("format(s={2,3};s):a.abc456'def'");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
// fails because there are trailing characters after 'c'
Version.parseVersion("format(s={2,3};.S={2,3};):aa.abc456'd'");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
}