/*******************************************************************************
* 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.*;
/**
* Tests the format(a) rule.
*
*/
public class FormatATest extends TestCase {
public void testNumeric() {
Version v = Version.parseVersion("format(a):1");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:1"), v);
}
public void testString() {
Version v = Version.parseVersion("format(a):a");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:'a'"), v);
}
public void testSequenceOfAuto() {
Version v = Version.parseVersion("format(aaaa):123abc456def");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:123.'abc'.456.'def'"), v);
}
/**
* Test that exact delimits a on count and type.
*/
public void testExact() {
Version v = Version.parseVersion("format(a={3};aaa={3};):123abc456def");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:123.'abc'.456.'def'"), v);
assertNotNull(v = Version.parseVersion("format(a={2};a):abc"));
assertEquals(Version.parseVersion("raw:'ab'.'c'"), v);
assertNotNull(v = Version.parseVersion("format(a={2};a):123"));
assertEquals(Version.parseVersion("raw:12.3"), v);
try {
// should fail because first segment is delimited after 2 chars
Version.parseVersion("format(a={4};aaa={3};):12.3abc456def");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
// should fail because first segment is delimited by type change after 3 chars
Version.parseVersion("format(a={4};aaa={3};):123abc456def");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
// should fail because first segment is delimited by type change after 3 chars
Version.parseVersion("format(a={4};aaa={3};):xyz123abc456");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
/**
* Test that unbound upper range delimits a on change of type.
*/
public void testAtLeast() {
Version v = Version.parseVersion("format(a={2,};aaa={2,};):123abc456def");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:123.'abc'.456.'def'"), v);
try {
Version.parseVersion("format(a={2,};aaa={2,};):1abc456def");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
Version.parseVersion("format(a={2,};aaa={2,};):12abc456d");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
/**
* test that at-most follows same rules as exact for the min range
*/
public void testAtMost() {
Version v = Version.parseVersion("format(a={1,3};aaa={1,3};):123abc456def");
assertNotNull(v);
assertEquals(Version.parseVersion("raw:123.'abc'.456.'def'"), v);
// change of type is delimiter
assertNotNull(v = Version.parseVersion("format(a={1,2};aaaa={1,2};a):123abc456def"));
assertEquals(Version.parseVersion("raw:12.3.'abc'.456.'de'.'f'"), v);
try {
Version.parseVersion("format(a={2,3};aaa={1,2};):1abc456def");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
Version.parseVersion("format(a={2,3};aaa={2,3};):12abc456d");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
try {
Version.parseVersion("format(a={4,5};aaa={1,4};):123abc456def");
fail();
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}
public void testEnum() {
Version v1 = Version.parseVersion("format(aa={alpha,beta,gamma};a):12beta2");
Version v2 = Version.parseVersion("raw:12.{alpha,^beta,gamma}.2");
assertEquals(v1, v2);
}
public void testEnumOptional() {
// When enum is optional, test that parser falls back to string when enum isn't matched
Version v1 = Version.parseVersion("format(aa={alpha,beta,gamma}?;a):12foo2");
Version v2 = Version.parseVersion("raw:12.'foo'.2");
assertEquals(v1, v2);
try {
Version.parseVersion("format(aa={alpha,beta,gamma};a):12foo2");
fail("bad enum was not detected");
} catch (IllegalArgumentException e) {
// Expected
}
}
public void testEnumIgnoreCase() {
// When enum is optional, test that parser falls back to string when enum isn't matched
Version v1 = Version.parseVersion("format(aa={Alpha,Beta,Gamma}i;a):12beta2");
Version v2 = Version.parseVersion("raw:12.{alpha,^beta,gamma}.2");
assertEquals(v1, v2);
v1 = Version.parseVersion("format(aa={alpha,beta,gamma}i;a):12BETA2");
v2 = Version.parseVersion("raw:12.{alpha,^beta,gamma}.2");
assertEquals(v1, v2);
try {
Version.parseVersion("format(aa={alpha,beta,gamma};a):12BETA2");
fail("enum case sensitivity ignored");
} catch (IllegalArgumentException e) {
// Expected
}
}
public void testEnumBegins() {
// When enum has 'begins', test that parser doesn't go too far
Version v1 = Version.parseVersion("format(aa={alpha,beta,gamma}b;aa):12gammafoo2");
Version v2 = Version.parseVersion("raw:12.{alpha,beta,^gamma}.'foo'.2");
assertEquals(v1, v2);
// When enum is optional, test that parser doesn't make attempts to resolve
v1 = Version.parseVersion("format(aa={alpha,beta,gamma}?;a):12gammafoo2");
v2 = Version.parseVersion("raw:12.'gammafoo'.2");
assertEquals(v1, v2);
// unless it's also a begins
v1 = Version.parseVersion("format(aa={alpha,beta,gamma}b?;aa):12gammafoo2");
v2 = Version.parseVersion("raw:12.{alpha,beta,^gamma}.'foo'.2");
assertEquals(v1, v2);
// if it's not optional nor begins, it should fail
try {
v1 = Version.parseVersion("format(aa={alpha,beta,gamma};a):12gammafoo2");
fail("Enum begins pattern resolved although begins was not specified");
} catch (IllegalArgumentException e) {
// Expected
}
// this one must fail too even though it's optional because
// it falls back to string and '#' is not a legal string character
try {
Version.parseVersion("format(aa={#,$,%}?;aa?):12#foo2");
fail("Enum fallback to string with illegal string character");
} catch (IllegalArgumentException e) {
// Expected
}
// This however, should work
v1 = Version.parseVersion("format(aa={#,$,%}b;aa):12#foo2");
v2 = Version.parseVersion("raw:12.{^#,$,%}.'foo'.2");
assertEquals(v1, v2);
}
public void testEnumFormatToString() {
Version v1 = Version.parseVersion("format(aa={alpha,beta,gamma};a):12beta2");
assertEquals(v1.toString(), "raw:12.{alpha,^beta,gamma}.2/format(aa={alpha,beta,gamma};a):12beta2");
}
public void testPHPVersion() {
IVersionFormat phpFormat = null;
try {
phpFormat = Version.compile("n(d=[_+.-];?a={dev,alpha=a,beta=b,RC=rc,#,pl=p}?;)*");
} catch (VersionFormatException e) {
fail(e.getMessage());
}
Version v1 = phpFormat.parse("1.2.3");
Version v2 = Version.parseVersion("raw:1.2.3");
assertEquals(v1, v2);
v1 = phpFormat.parse("1.2.alpha2");
v2 = phpFormat.parse("1.2.a2");
assertEquals(v1, v2);
v1 = phpFormat.parse("1.2.beta3");
v2 = phpFormat.parse("1.2.#2");
assertTrue(v1.compareTo(v2) < 0);
assertTrue(v2.compareTo(v1) > 0);
v1 = Version.parseVersion("raw:1.2.{dev,a,b,RC,^#,p}.2");
assertEquals(v1, v2);
v1 = Version.parseVersion("raw:1.2.{dev,a,b,^rc,#,p}.2");
assertTrue(v1.compareTo(v2) < 0);
assertTrue(v2.compareTo(v1) > 0);
v1 = Version.parseVersion("raw:1.2.{dev,a,b,rc,#,^p}.2");
assertTrue(v1.compareTo(v2) > 0);
assertTrue(v2.compareTo(v1) < 0);
}
}