Google Git
Sign in
eclipse / mat / org.eclipse.mat / 3bb7dda0a9ae98ba79ead8d8ed2adb268328b81b / . / plugins / org.eclipse.mat.tests / src / org / eclipse / mat / tests / snapshot / OQLTest.java
blob: 65c07a5c69221d12a6cd8c48bcd263e51cae7d19 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2008, 2019 SAP AG and IBM Corporation.
* 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:
* SAP AG - initial API and implementation
* IBM Corporation - test AS clause
* IBM Corporation - test instanceof with object id/address
*******************************************************************************/
package org.eclipse.mat.tests.snapshot;
import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.Matchers.anyOf;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.hasItems;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.mat.SnapshotException;
import org.eclipse.mat.collect.ArrayInt;
import org.eclipse.mat.collect.IteratorInt;
import org.eclipse.mat.query.ContextProvider;
import org.eclipse.mat.query.IContextObject;
import org.eclipse.mat.query.IContextObjectSet;
import org.eclipse.mat.query.IResultTable;
import org.eclipse.mat.snapshot.IOQLQuery;
import org.eclipse.mat.snapshot.ISnapshot;
import org.eclipse.mat.snapshot.OQL;
import org.eclipse.mat.snapshot.OQLParseException;
import org.eclipse.mat.snapshot.SnapshotFactory;
import org.eclipse.mat.snapshot.model.IClass;
import org.eclipse.mat.snapshot.model.IObject;
import org.eclipse.mat.tests.TestSnapshots;
import org.eclipse.mat.util.MessageUtil;
import org.eclipse.mat.util.VoidProgressListener;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
@SuppressWarnings("nls")
public class OQLTest
{
@Test
public void testUnreservedKeywords() throws SnapshotException
{
SnapshotFactory.createQuery("SELECT * FROM something.as.Object");
SnapshotFactory.createQuery("SELECT * FROM something.distinct.Object");
SnapshotFactory.createQuery("SELECT * FROM something.from.Object");
SnapshotFactory.createQuery("SELECT * FROM something.in.Object");
SnapshotFactory.createQuery("SELECT * FROM something.is.Object");
SnapshotFactory.createQuery("SELECT * FROM something.like.Object");
SnapshotFactory.createQuery("SELECT * FROM something.not.Object");
SnapshotFactory.createQuery("SELECT * FROM something.objects.Object");
SnapshotFactory.createQuery("SELECT * FROM something.union.Object");
SnapshotFactory.createQuery("SELECT * FROM something.where.Object");
}
@Test
public void testErrorParseException() throws SnapshotException
{
String[] statements = new String[] { "select dominatorsof(s) from", //
"SELECT * FROM something.as retained set", //
"SELECT * FROM x WHERE" };
for (String statement : statements)
{
try
{
SnapshotFactory.createQuery(statement);
throw new SnapshotException(MessageUtil.format("Statement should generated error: {0}", statement));
}
catch (OQLParseException expected)
{}
}
}
@Test
public void testSelectStar() throws SnapshotException
{
Object result = execute("select * from java.lang.String");
assertThat("'SELECT *' must return a result of type int[]", result, instanceOf(int[].class));
int[] objectIds = (int[]) result;
assertThat("492 objects of type java.lang.String expected", objectIds.length, equalTo(492));
}
@Test
public void testSelectAttributes() throws SnapshotException
{
Object result = execute("select s.@objectId, s.value, s.count, s.offset from java.lang.String s");
assertThat("'SELECT x, y, z' must return a result of type IResultTable", result, instanceOf(IResultTable.class));
IResultTable table = (IResultTable) result;
assertThat("492 objects of type java.lang.String expected", table.getRowCount(), equalTo(492));
assertThat("4 columns expected", table.getColumns().length, equalTo(4));
// check if context is available
Object row = table.getRow(0);
int objectId = (Integer) table.getColumnValue(row, 0);
assertThat("Result must return underlying object id as context", objectId, equalTo(table.getContext(row).getObjectId()));
checkGetOQL(table);
}
@Test
public void testSelectRetained1() throws SnapshotException
{
int[] objectIds = (int[]) execute("select as retained set * from java.lang.String");
assertThat("963 objects expected", objectIds.length, equalTo(963));
}
@Test
public void testSelectRetained2() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT AS RETAINED SET * FROM OBJECTS ( SELECT * FROM java.lang.String ) s ");
assertThat("963 objects expected", objectIds.length, equalTo(963));
}
@Test
public void testSelectRetained3() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT AS RETAINED SET OBJECTS s FROM OBJECTS ( SELECT * FROM java.lang.String ) s ");
assertThat("963 objects expected", objectIds.length, equalTo(963));
}
@Test
public void testSelectRetained4() throws SnapshotException
{
IResultTable resulttable = (IResultTable)execute("SELECT AS RETAINED SET s FROM OBJECTS ( SELECT * FROM java.lang.String ) s ");
assertThat("963 objects expected", resulttable.getRowCount(), equalTo(963));
checkGetOQL(resulttable);
}
@Test
public void testSelectObjects() throws SnapshotException
{
int[] objectIds = (int[]) execute("select objects dominators(s) from objects 0x1295e2f8 s");
assertThat(objectIds.length, equalTo(7));
objectIds = (int[]) execute("select objects dominators(s) from objects ${snapshot}.getClassesByName(\"java.lang.String\", false) s");
assertThat(objectIds.length, equalTo(2));
objectIds = (int[]) execute("select objects dominators(s) from objects (select * from java.lang.String) s");
assertThat(objectIds.length, equalTo(465));
}
@Test
public void testDistinct1() throws SnapshotException
{
Object result = execute("select distinct objects classof(s) from java.lang.String s");
assertThat("'SELECT distinct objects' must return a result of type int[]", result, instanceOf(int[].class));
int[] objectIds = (int[]) result;
assertThat("1 object of type java.lang.Class expected", objectIds.length, equalTo(1));
}
@Test
public void testDistinct2() throws SnapshotException
{
Object result = execute("select distinct classof(s) from java.lang.String s");
assertThat("'SELECT distinct' must return a result of type IResultTable", result, instanceOf(IResultTable.class));
IResultTable resulttable = (IResultTable) result;
assertThat("1 object of type java.lang.Class expected", resulttable.getRowCount(), equalTo(1));
checkGetOQL(resulttable);
}
@Test
public void testDistinct3() throws SnapshotException
{
Object result = execute("SELECT DISTINCT z FROM OBJECTS ( SELECT classof(s) FROM java.lang.String s ) z");
assertThat("'SELECT distinct' must return a result of type IResultTable", result, instanceOf(IResultTable.class));
IResultTable resulttable = (IResultTable) result;
assertThat("1 object of type java.lang.Class expected", resulttable.getRowCount(), equalTo(1));
checkGetOQL(resulttable);
}
@Test
public void testOperations1int() throws SnapshotException
{
Object result = execute("select * from objects ((1+2+3--2-2)*-4/-3)");
assertEquals(8.0, result);
}
@Test
public void testOperations1long() throws SnapshotException
{
Object result = execute("select * from objects ((1L+2L+3L--2L-2L)*-4L/-3L)");
assertEquals(8.0, result);
}
@Test
public void testOperations1double() throws SnapshotException
{
Object result = execute("select * from objects ((1.0+2.0+3.0--2.0-2.0)*-4.0/-3.0)");
assertEquals(8.0, result);
}
@Test
public void testOperations2int() throws SnapshotException
{
Object result = execute("select * from objects (1=1 AND 3<2 OR 4>3 AND 4>=4 AND 4 <= 4 AND 4 < 5)");
assertEquals(true, result);
}
@Test
public void testOperations2long() throws SnapshotException
{
Object result = execute("select * from objects (1L=1L AND 3L<2L OR 4L>3L AND 4L>=4L AND 4L <= 4L AND 4L < 5L)");
assertEquals(true, result);
}
@Test
public void testOperations2double() throws SnapshotException
{
Object result = execute("select * from objects (1.0=1.0 AND 3.0<2.0 OR 4.0>3.0 AND 4.0>=4.0 AND 4.0 <= 4.0 AND 4.0 < 5.0)");
assertEquals(true, result);
}
@Test
public void testOperations2date() throws SnapshotException
{
Object result = execute("select * from objects (" +
"${snapshot}.@snapshotInfo.@creationDate < ${snapshot}.@snapshotInfo.@creationDate OR " +
"${snapshot}.@snapshotInfo.@creationDate > ${snapshot}.@snapshotInfo.@creationDate OR " +
"${snapshot}.@snapshotInfo.@creationDate != ${snapshot}.@snapshotInfo.@creationDate OR " +
"${snapshot}.@snapshotInfo.@creationDate = ${snapshot}.@snapshotInfo.@creationDate AND " +
"${snapshot}.@snapshotInfo.@creationDate <= ${snapshot}.@snapshotInfo.@creationDate AND " +
"${snapshot}.@snapshotInfo.@creationDate >= ${snapshot}.@snapshotInfo.@creationDate)");
assertEquals(true, result);
}
@Test
public void testUnion() throws SnapshotException
{
int[] objectIds = (int[]) execute("select * from objects 0 union (select * from objects 1)");
assertThat(objectIds.length, equalTo(2));
IResultTable table = (IResultTable) execute("select toString(s) from objects 0x17c180b8 s union (select toHex(s.@objectAddress) from objects 1 s)");
assertThat(table.getRowCount(), equalTo(2));
assertThat(table.getColumnValue(table.getRow(0), 0), equalTo((Object)"main"));
assertThat(table.getColumnValue(table.getRow(1), 0), equalTo((Object)"0x12832b50"));
checkGetOQL(table);
}
@Test
public void testUnionCommand1() throws SnapshotException
{
String oql = "select * from objects 0,1 union (select * from objects 1,2)";
IOQLQuery q1 = SnapshotFactory.createQuery(oql);
String oql2 = q1.toString();
IOQLQuery q2 = SnapshotFactory.createQuery(oql2);
String oql3 = q2.toString();
assertEquals(oql2, oql3);
}
@Test
public void testUnionCommand1a() throws SnapshotException
{
int[] r = (int[])execute("select * from objects 0,1 union (select * from objects 1,2)");
// Should this be 3 (distinct elements) or 4 (union all)
//assertEquals(3, r.length);
//assertEquals(4, r.length);
assertTrue(r.length == 3 || r.length == 4);
}
@Test
public void testUnionCommand2() throws SnapshotException
{
String oql = "select s from objects 0,1 s union (select t from objects 1,2 t)";
Object r = execute(oql);
IOQLQuery.Result oo = (IOQLQuery.Result)r;
String oql2 = oo.getOQLQuery();
r = execute(oql2);
oo = (IOQLQuery.Result)r;
String oql3 = oo.getOQLQuery();
assertEquals(oql2, oql3);
}
@Test
public void testUnionCommand2a() throws SnapshotException
{
IResultTable t = (IResultTable)execute("select s from objects 0,1 s union (select t from objects 1,2 t)");
// Should this be 3 (distinct elements) or 4 (union all)
//assertEquals(3, t.getRowCount());
//assertEquals(4, t.getRowCount());
assertTrue(t.getRowCount() == 3 || t.getRowCount() == 4);
checkGetOQL(t);
}
@Test
public void testUnionCommand3() throws SnapshotException
{
String oql = "select * from notfound union (select * from objects 1,2)";
IOQLQuery q1 = SnapshotFactory.createQuery(oql);
String oql2 = q1.toString();
IOQLQuery q2 = SnapshotFactory.createQuery(oql2);
String oql3 = q2.toString();
assertEquals(oql2, oql3);
}
@Test
public void testUnionCommand3a() throws SnapshotException
{
int[] r = (int[])execute("select * from notfound union (select * from objects 1,2)");
assertEquals(2, r.length);
}
@Test
public void testUnionCommand4() throws SnapshotException
{
String oql = "select s from notfound s union (select t from objects 1,2 t)";
Object r = execute(oql);
IOQLQuery.Result oo = (IOQLQuery.Result)r;
String oql2 = oo.getOQLQuery();
r = execute(oql2);
oo = (IOQLQuery.Result)r;
String oql3 = oo.getOQLQuery();
assertEquals(oql2, oql3);
}
@Test
public void testUnionCommand4a() throws SnapshotException
{
IResultTable t = (IResultTable)execute("select s from notfound s union (select t from objects 1,2 t)");
assertEquals(2, t.getRowCount());
checkGetOQL(t);
}
@Test
public void testUnionCommand5() throws SnapshotException
{
String oql = "select * from objects 0,1 union (select * from notfound)";
IOQLQuery q1 = SnapshotFactory.createQuery(oql);
String oql2 = q1.toString();
IOQLQuery q2 = SnapshotFactory.createQuery(oql2);
String oql3 = q2.toString();
assertEquals(oql2, oql3);
}
@Test
public void testUnionCommand5a() throws SnapshotException
{
int[] r = (int[])execute("select * from objects 0,1 union (select * from notfound)");
assertEquals(2, r.length);
}
@Test
public void testUnionCommand6() throws SnapshotException
{
String oql = "select s from objects 0,1 s union (select t from notfound t)";
Object r = execute(oql);
IOQLQuery.Result oo = (IOQLQuery.Result)r;
String oql2 = oo.getOQLQuery();
r = execute(oql2);
oo = (IOQLQuery.Result)r;
String oql3 = oo.getOQLQuery();
assertEquals(oql2, oql3);
}
@Test
public void testUnionCommand6a() throws SnapshotException
{
IResultTable t = (IResultTable)execute("select s from objects 0,1 s union (select t from notfound t)");
assertEquals(2, t.getRowCount());
checkGetOQL(t);
}
@Test
public void testUnionCommand7() throws SnapshotException
{
int[] r = (int[])execute("select distinct * from objects 0,0,1 union (select * from objects 1,1,2,2)");
assertEquals(6, r.length);
}
@Test
public void testUnionCommand8() throws SnapshotException
{
int[] r = (int[])execute("select * from objects 0,0,1 union (select distinct * from objects 1,1,2,2)");
assertEquals(5, r.length);
}
@Test
public void testUnionCommand9() throws SnapshotException
{
int[] r = (int[])execute("select distinct * from objects 0,0,1 union (select distinct * from objects 1,1,2,2)");
assertEquals(4, r.length);
}
@Test
public void testUnionCommand10() throws SnapshotException
{
String oql = "SELECT s FROM missing s UNION (SELECT s FROM missing s ) UNION (SELECT s FROM java.lang.String s )";
IOQLQuery.Result r = (IOQLQuery.Result)execute(oql);
assertEquals(oql, r.getOQLQuery());
assertEquals(492, ((IResultTable)r).getRowCount());
checkGetOQL((IResultTable)r);
}
@Test
public void testUnionCommand11() throws SnapshotException
{
String oql = "SELECT s FROM java.lang.String[] s UNION (SELECT s FROM missing s ) UNION (SELECT s FROM java.lang.String s )";
IOQLQuery.Result r = (IOQLQuery.Result)execute(oql);
assertEquals(oql, r.getOQLQuery());
assertEquals(28 + 492, ((IResultTable)r).getRowCount());
checkGetOQL((IResultTable)r);
}
@Test
public void testUnionCommand12() throws SnapshotException
{
String oql = "SELECT * FROM missing UNION (SELECT * FROM missing ) UNION (SELECT * FROM java.lang.String )";
int r[] = (int[])execute(oql);
assertEquals(492, r.length);
}
@Test
public void testUnionCommand13() throws SnapshotException
{
String oql = "SELECT * FROM java.lang.String[] UNION (SELECT * FROM missing ) UNION (SELECT * FROM java.lang.String )";
int r[] = (int[])execute(oql);
assertEquals(28 + 492, r.length);
}
@Test
public void testFromPattern() throws SnapshotException
{
Object result = execute("select * from \"java.lang.*\"");
assertThat("'SELECT *' must return a result of type int[]", result, instanceOf(int[].class));
int[] objectIds = (int[]) result;
assertThat("1198 objects of type java.lang.* expected", objectIds.length, equalTo(1198));
}
@Test
public void testFromAddress() throws SnapshotException
{
Object result = execute("select * from objects 0x0");
assertThat("'SELECT *' must return a result of type int[]", result, instanceOf(int[].class));
int[] objectIds = (int[]) result;
assertThat("one object matching 0x0 expected", objectIds.length, equalTo(1));
}
@Test
public void testFromObject() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT * FROM ${snapshot}.getClassesByName(\"java.lang.ref.Reference\", true)");
assertThat("expected 21 instanceof of java.lang.ref.Reference", objectIds.length, equalTo(21));
}
@Test
public void testFromByName1() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT s, snapshot FROM OBJECTS ${snapshot}.getClassesByName(\"java.lang.Class\",false).iterator().next().getObjectIds() s WHERE ${snapshot}.isClass(s)");
ISnapshot sn = (ISnapshot)irt.getColumnValue(0, 1);
assertThat(irt.getRowCount(), equalTo(sn.getSnapshotInfo().getNumberOfClasses()));
}
@Test
public void testFromByName2() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT t FROM ("
+ "SELECT OBJECTS s FROM OBJECTS ${snapshot}.getClassesByName(\"java.lang.Class\",false).iterator().next().getObjectIds() s WHERE ${snapshot}.isClass(s)"
+ ") t");
IObject o = (IObject)irt.getColumnValue(0, 0);
assertThat(irt.getRowCount(), equalTo(o.getSnapshot().getSnapshotInfo().getNumberOfObjects()));
checkGetOQL(irt);
}
@Test
public void testFromByName3() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT t,snapshot FROM ( eval(("
+ "SELECT OBJECTS s FROM OBJECTS ${snapshot}.getClassesByName(\"java.lang.Class\",false).iterator().next().getObjectIds() s WHERE ${snapshot}.isClass(s)"
+ "))"
+ ") t");
IObject o = (IObject)irt.getColumnValue(0, 0);
assertThat(irt.getRowCount(), equalTo(o.getSnapshot().getSnapshotInfo().getNumberOfObjects()));
checkGetOQL(irt);
}
@Test
public void testFromByName4() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT s,snapshot FROM OBJECTS ${snapshot}.getClassesByName(\"java.lang.Object\",true).toArray() s WHERE ${snapshot}.isClass(s.@objectId)");
ISnapshot sn = (ISnapshot)irt.getColumnValue(0, 1);
assertThat(irt.getRowCount(), equalTo(sn.getSnapshotInfo().getNumberOfClasses()));
checkGetOQL(irt);
}
@Test
public void testFromByName5() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT s, snapshot FROM ${snapshot}.getClassesByName(\"java.lang.Object\",true).toArray() s WHERE ${snapshot}.isClass(s.@objectId)");
ISnapshot sn = (ISnapshot)irt.getColumnValue(0, 1);
assertThat(irt.getRowCount(), equalTo(sn.getSnapshotInfo().getNumberOfClasses()));
checkGetOQL(irt);
}
@Test
public void testFromByName6() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT s, snapshot FROM INSTANCEOF ${snapshot}.getClassesByName(\"java.lang.Object\",false).toArray() s WHERE ${snapshot}.isClass(s.@objectId)");
ISnapshot sn = (ISnapshot)irt.getColumnValue(0, 1);
assertThat(irt.getRowCount(), equalTo(sn.getSnapshotInfo().getNumberOfClasses()));
checkGetOQL(irt);
}
@Test
public void testFromByName7() throws SnapshotException
{
IResultTable irt = (IResultTable)execute("SELECT AS RETAINED SET s, snapshot FROM ${snapshot}.getClassesByName(\"java.lang.Class\",false) s");
ISnapshot sn = (ISnapshot)irt.getColumnValue(0, 1);
assertThat(irt.getRowCount(), greaterThan(sn.getSnapshotInfo().getNumberOfClasses()));
checkGetOQL(irt);
}
@Test
public void testFromSubSelect() throws SnapshotException
{
String oql = "SELECT * FROM ( SELECT * " //
+ "FROM java.lang.Class c " //
+ "WHERE c implements org.eclipse.mat.snapshot.model.IClass )";
int[] objectIds = (int[]) execute(oql);
assertThat("expected 2058 instances of IClass", objectIds.length, equalTo(2058));
}
@Test
public void testImplements() throws SnapshotException
{
String oql = "SELECT * " //
+ "FROM java.lang.Class c " //
+ "WHERE c implements org.eclipse.mat.snapshot.model.IClass ";
IOQLQuery q1 = SnapshotFactory.createQuery(oql);
String oql2 = q1.toString();
int[] objectIds = (int[]) execute(oql2);
assertEquals("expected 383 instances of IClass", 383, objectIds.length);
}
@Test
public void testFromInstanceOf() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT * FROM INSTANCEOF java.lang.ref.Reference");
assertThat("expected 21 instances of java.lang.ref.Reference", objectIds.length, equalTo(21));
ISnapshot snapshot = TestSnapshots.getSnapshot(TestSnapshots.SUN_JDK5_64BIT, false);
Collection<IClass>rClasses = snapshot.getClassesByName("java.lang.ref.Reference", true);
assertNotNull(rClasses);
Set<IClass> classes = new HashSet<IClass>(rClasses);
for (int id : objectIds)
{
assertThat(MessageUtil.format("Object {0} not an instance of java.lang.ref.Reference ", id),
classes, hasItems(snapshot.getClassOf(id)));
assert classes.contains(snapshot.getClassOf(id)) : MessageUtil.format(
"Object {0} not an instance of java.lang.ref.Reference ", id);
}
}
@Test
public void testWhereRelationalOperators() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count > 51");
assertThat(objectIds.length, equalTo(16));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count >= 51");
assertThat(objectIds.length, equalTo(19));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count < 51");
assertThat(objectIds.length, equalTo(473));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count <= 51");
assertThat(objectIds.length, equalTo(476));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE toString(s) LIKE \"java.*\"");
assertThat(objectIds.length, equalTo(27));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE toString(s) NOT LIKE \"java.*\"");
assertThat(objectIds.length, equalTo(492 - 27));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.value IN dominators(s)");
assertThat(objectIds.length, equalTo(492 - 27));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.value NOT IN dominators(s)");
assertThat(objectIds.length, equalTo(27));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE toString(s) = \"file.separator\"");
assertThat(objectIds.length, equalTo(1));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count > 100 AND s.@retainedHeapSize > s.@usedHeapSize");
assertThat(objectIds.length, equalTo(6));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count > 1000 OR s.value.@length > 1000");
assertThat(objectIds.length, equalTo(3));
}
/**
* Check reads of attributes declared in subclasses
* @throws SnapshotException
*/
@Test
public void testWhereRelationalOperatorsOnAttributes() throws SnapshotException
{
int[] objectIds = (int[]) execute("select * from instanceof java.util.Vector s where s.elementCount < 10");
assertEquals("Expected to read ", 11, objectIds.length);
}
/**
* Check reads of statics declared in classes
* @throws SnapshotException
*/
@Test
public void testWhereRelationalOperatorsOnStaticAttributes() throws SnapshotException
{
int[] objectIds = (int[]) execute("select * from java.lang.Class s where s.serialVersionUID.toString().contains(\"-\")");
assertEquals("Expected to read ", 52, objectIds.length);
}
@Test
public void testWhereArithmetic() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count < s.value.@length * 0.5");
assertThat(objectIds.length, equalTo(16));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count < s.value.@length / 2");
assertThat(objectIds.length, equalTo(16));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count < s.value.@length - 20");
assertThat(objectIds.length, equalTo(16));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.count + 20 < s.value.@length");
assertThat(objectIds.length, equalTo(16));
}
@Test
public void testWhereArithmeticInt() throws SnapshotException
{
// get(int) with an int, not a long
int[] objectIds0 = (int[])execute("SELECT * FROM int[]");
int[] objectIds1 = (int[])execute("SELECT * FROM int[] c WHERE (c.@valueArray.get(c.@length - 1) > 0)");
int[] objectIds2 = (int[])execute("SELECT * FROM int[] c WHERE (c.@valueArray.get(c.@length + -1) <= 0)");
assertEquals(objectIds0.length, objectIds1.length + objectIds2.length);
}
@Test
public void testWhereLiterals() throws SnapshotException
{
int[] objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE ( s.count > 1000 ) = true");
assertThat(objectIds.length, equalTo(3));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE dominators(s).size() = 0");
assertThat(objectIds.length, equalTo(27));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE dominators(s).length = 0");
assertThat(objectIds.length, equalTo(27));
objectIds = (int[]) execute("SELECT * FROM java.lang.String s WHERE s.@retainedHeapSize > 1024L");
assertThat(objectIds.length, equalTo(4));
objectIds = (int[]) execute("SELECT * FROM java.lang.Thread s WHERE s.@GCRootInfo != null");
assertThat(objectIds.length, equalTo(4));
}
@Test
public void testBuildInFunctions() throws SnapshotException
{
ISnapshot snapshot = TestSnapshots.getSnapshot(TestSnapshots.SUN_JDK5_64BIT, false);
int objectId = ((int[]) execute("select * from objects 0x17c38b80 s"))[0];
IResultTable result = (IResultTable) execute("select toString(s) from objects 0x17c38b80 s");
assertThat(result.getColumnValue(result.getRow(0), 0), equalTo((Object)"little"));
result = (IResultTable) execute("select toHex(s.@objectAddress) from objects 0x17c38b80 s");
assertThat(result.getColumnValue(result.getRow(0), 0), equalTo((Object)"0x17c38b80"));
result = (IResultTable) execute("select dominators(s).length from objects 0x17c38b80 s");
assertThat(result.getColumnValue(result.getRow(0), 0), equalTo((Object)1));
result = (IResultTable) execute("select outbounds(s) from objects 0x17c38b80 s");
int[] outbounds = (int[]) result.getColumnValue(result.getRow(0), 0);
assertThat(outbounds.length, equalTo(2));
assertThat(outbounds, equalTo(snapshot.getOutboundReferentIds(objectId)));
result = (IResultTable) execute("select inbounds(s) from objects 0x17c38b80 s");
int[] inbounds = (int[]) result.getColumnValue(result.getRow(0), 0);
assertThat(inbounds.length, equalTo(1));
assertThat(inbounds, equalTo(snapshot.getInboundRefererIds(objectId)));
result = (IResultTable) execute("select classof(s) from objects 0x17c38b80 s");
IClass obj = (IClass) result.getColumnValue(result.getRow(0), 0);
assertThat(obj.getName(), equalTo("java.lang.String"));
result = (IResultTable) execute("select dominatorof(s) from objects 0x17c38b80 s");
assertNotNull(result.getColumnValue(result.getRow(0), 0));
}
@Test(expected = SnapshotException.class)
public void testErrorRuntimeException() throws SnapshotException
{
execute("select s from objects 0 where dominatorof(s) = 0");
}
/**
* Test spaces in as clause
* @throws SnapshotException
*/
@Test
public void testAsSpaces() throws SnapshotException
{
String label = "A B";
IOQLQuery q1 = SnapshotFactory.createQuery("SELECT s.@objectId AS \"" + label + "\" FROM java.lang.Object s");
String s = q1.toString();
IResultTable r = (IResultTable)execute(s);
assertEquals(label, r.getColumns()[0].getLabel());
IOQLQuery q2 = SnapshotFactory.createQuery(s);
String s2 = q2.toString();
assertEquals(s, s2);
checkGetOQL(r);
}
/**
* Test empty as clause
* @throws SnapshotException
*/
@Test
public void testAsEmpty() throws SnapshotException
{
String label = "";
IOQLQuery q1 = SnapshotFactory.createQuery("SELECT s.@objectId AS \"" + label + "\" FROM java.lang.Object s");
String s = q1.toString();
IResultTable r = (IResultTable)execute(s);
assertEquals(label, r.getColumns()[0].getLabel());
IOQLQuery q2 = SnapshotFactory.createQuery(s);
String s2 = q2.toString();
assertEquals(s, s2);
checkGetOQL(r);
}
/**
* Test punctuation in as clause
* @throws SnapshotException
*/
@Test
public void testAsPunctution() throws SnapshotException
{
String label = "A,B";
IOQLQuery q1 = SnapshotFactory.createQuery("SELECT s.@objectId AS \"" + label + "\" FROM java.lang.Object s");
String s = q1.toString();
IResultTable r = (IResultTable)execute(s);
assertEquals(label, r.getColumns()[0].getLabel());
IOQLQuery q2 = SnapshotFactory.createQuery(s);
String s2 = q2.toString();
assertEquals(s, s2);
checkGetOQL(r);
}
/**
* Test AND clause is not collapsed.
* @throws SnapshotException
*/
@Test
public void testAndClauseSpaces() throws SnapshotException
{
final String queryString = "SELECT s.value FROM INSTANCEOF java.lang.Number s WHERE (true and s.value)";
IOQLQuery q1 = SnapshotFactory.createQuery(queryString);
String s = q1.toString();
IOQLQuery q2 = SnapshotFactory.createQuery(s);
String s2 = q2.toString();
assertEquals(s, s2);
IResultTable r = (IResultTable)execute(s);
checkGetOQL(r);
}
/**
* Test AND clause is evaluated.
* @throws SnapshotException
*/
@Test
public void testAndClause() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s.value FROM INSTANCEOF java.lang.Number s WHERE (s.value and true)");
assertThat("3 non-zero Numbers expected", res.getRowCount(), equalTo(3));
}
@Test
public void testConversionsLong1() throws SnapshotException
{
// Array of 2 Strings and an object array
int res[] = (int[])execute("SELECT OBJECTS @referenceArray.get(0) FROM OBJECTS 0x17c17128");
assertEquals(1, res.length);
}
@Test
public void testConversionsLong() throws SnapshotException
{
// Array of 2 Strings and an object array
int res[] = (int[])execute("SELECT OBJECTS @referenceArray FROM OBJECTS 0x17c17128");
assertEquals(3, res.length);
}
@Test
public void testGetClasses1() throws SnapshotException
{
// 21 byte arrays
int res[] = (int[])execute("SELECT * FROM ${snapshot}.getClasses().get(2)");
assertEquals(21, res.length);
}
@Test
public void testGetClasses2() throws SnapshotException
{
// 21 byte arrays
int res[] = (int[])execute("SELECT * FROM (SELECT OBJECTS s FROM OBJECTS ${snapshot}.getClasses().get(2).@objectId s)");
assertEquals(21, res.length);
}
@Test
public void testGetClasses3() throws SnapshotException
{
// 21 byte arrays
Class<?> s = (Class<?>)execute("SELECT * FROM OBJECTS ${snapshot}.getClasses().@class");
assertEquals("class java.util.Arrays$ArrayList", s.toString());
}
@Test
public void testGetClasses4() throws SnapshotException
{
// 492 Strings
int[] objectIds = (int[])execute("select * from java.lang.String s where (select * from objects ${snapshot}.isClass(s.@objectId)) = false");
assertEquals(492, objectIds.length);
}
@Test
public void testInstanceOf1() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from instanceof java.util.AbstractMap");
assertEquals(25, objectIds.length);
}
@Test
public void testInstanceOf2() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from instanceof 0x128da800");
assertEquals(25, objectIds.length);
}
@Test
public void testInstanceOf3() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from instanceof 120");
assertEquals(25, objectIds.length);
}
@Test
public void testInstanceOf4() throws SnapshotException
{
// 10 Abstract Map classes
int[] objectIds = (int[])execute("select * from objects instanceof java.util.AbstractMap");
assertEquals(10, objectIds.length);
}
@Test
public void testInstanceOf5() throws SnapshotException
{
// 10 Abstract Map classes
int[] objectIds = (int[])execute("select * from objects instanceof 0x128da800");
assertEquals(10, objectIds.length);
}
@Test
public void testInstanceOf6() throws SnapshotException
{
// 10 Abstract Map classes
int[] objectIds = (int[])execute("select * from objects instanceof 120");
assertEquals(10, objectIds.length);
}
@Test
public void testInstanceOf7() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from instanceof (select * from objects java.util.AbstractMap)");
assertEquals(25, objectIds.length);
}
@Test
public void testInstanceOf8() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from objects instanceof (select * from objects java.util.AbstractMap)");
assertEquals(10, objectIds.length);
}
@Test
public void testInstanceOf9() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from instanceof ${snapshot}.getClassesByName(\"java.util.AbstractMap\", false)");
assertEquals(25, objectIds.length);
}
@Test
public void testInstanceOf10() throws SnapshotException
{
// 25 Abstract Maps
int[] objectIds = (int[])execute("select * from objects instanceof ${snapshot}.getClassesByName(\"java.util.AbstractMap\", false)");
assertEquals(10, objectIds.length);
}
@Test
public void testOverloadedMethod1() throws SnapshotException
{
// 80 objects - baseline for other tests
int[] objectIds = (int[])execute("SELECT * FROM \".....i.*\"");
assertEquals(80, objectIds.length);
}
@Test
public void testOverloadedMethod2() throws SnapshotException
{
// 80 objects
// indexOf(String)
int[] objectIds = (int[])execute("SELECT * FROM \".*\" c WHERE (c.@clazz.@name.indexOf(\"i\") = 5)");
assertEquals(80, objectIds.length);
}
@Test
public void testOverloadedMethod3() throws SnapshotException
{
// 80 objects
// indexOf(int) with a char
int[] objectIds = (int[])execute("SELECT * FROM \".*\" c WHERE (c.@clazz.@name.indexOf('i') = 5)");
assertEquals(80, objectIds.length);
}
@Test
public void testOverloadedMethod4() throws SnapshotException
{
// 80 objects
// indexOf(int) with an int
int[] objectIds = (int[])execute("SELECT * FROM \".*\" c WHERE (c.@clazz.@name.indexOf(105) = 5)");
assertEquals(80, objectIds.length);
}
@Test
public void testPrimitiveArray() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s[2] FROM int[] s");
assertEquals(5, res.getRowCount());
checkGetOQL(res);
}
@Test
public void testObjectArray() throws SnapshotException
{
int[] objectIds = (int[])execute("SELECT OBJECTS s[2] FROM byte[][] s");
assertEquals(2, objectIds.length);
}
@Test
public void testJavaArray() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s.@GCRoots[2] FROM OBJECTS ${snapshot} s");
assertEquals(1, res.getRowCount());
checkGetOQL(res);
}
@Test
public void testJavaList() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s.@GCRoots.subList(1,3)[1] FROM OBJECTS ${snapshot} s");
assertEquals(1, res.getRowCount());
checkGetOQL(res);
}
/**
* Check IObject returned from FROM OBJECTS
* @throws SnapshotException
*/
@Test
public void testDirectIObject() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT v, v.@objectId "
+ "FROM OBJECTS ${snapshot}.getObject(123) v");
assertEquals(1, res.getRowCount());
assertEquals(123, res.getColumnValue(res.getRow(0), 1));
checkGetOQL(res);
}
@Test
public void testPrimitiveArrayRange() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s[1:3][1] FROM int[] s");
assertEquals(5, res.getRowCount());
checkGetOQL(res);
}
@Test
public void testObjectArrayRange() throws SnapshotException
{
int[] objectIds = (int[])execute("SELECT OBJECTS s[1:3][1] FROM byte[][] s");
assertEquals(2, objectIds.length);
}
@Test
public void testJavaArrayRange() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s.@GCRoots[1:3][1] FROM OBJECTS ${snapshot} s");
assertEquals(1, res.getRowCount());
checkGetOQL(res);
}
@Test
public void testJavaArrayRange2() throws SnapshotException
{
int res[] = (int[])execute("SELECT OBJECTS s.@GCRoots[1:3] FROM OBJECTS ${snapshot} s");
assertEquals(3, res.length);
}
@Test
public void testJavaArrayRange3() throws SnapshotException
{
int res[] = (int[])execute("SELECT OBJECTS s.@GCRoots[-2:-1] FROM OBJECTS ${snapshot} s");
assertEquals(2, res.length);
}
@Test
public void testJavaListRange() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s.@GCRoots.subList(0,3)[1:3][1] FROM OBJECTS ${snapshot} s");
assertEquals(1, res.getRowCount());
checkGetOQL(res);
}
@Test
public void testPrimitiveArrayRange2() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT s[1:3][1] FROM int[] s");
assertEquals(5, res.getRowCount());
IResultTable res2 = (IResultTable)execute("SELECT s[(1 - s.@length):(3 - s.@length)][1] FROM int[] s");
assertEquals(5, res.getRowCount());
assertEquals(res.getColumnValue(res.getRow(2), 0), res2.getColumnValue(res2.getRow(2), 0));
checkGetOQL(res);
checkGetOQL(res2);
}
@Test
public void testConcatentation() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT \"ABC\"+s FROM OBJECTS (123) s");
assertEquals(1, res.getRowCount());
Object r = res.getRow(0);
Object val = res.getColumnValue(r, 0);
assertEquals("ABC123", val);
checkGetOQL(res);
}
@Test
public void testEval() throws SnapshotException
{
IResultTable res = (IResultTable)execute("SELECT eval(\"ABC\"+s) FROM OBJECTS (123) s");
assertEquals(1, res.getRowCount());
Object r = res.getRow(0);
Object val = res.getColumnValue(r, 0);
assertEquals("ABC123", val);
checkGetOQL(res);
}
@Test
public void testOQLunion1() {
StringBuilder sb = new StringBuilder();
sb.append("select s from 1,2,3 s1");
OQL.union(sb, "select s from 17,23 s1");
assertEquals("select s from 1,2,3,17,23 s1", sb.toString());
}
@Test
public void testOQLunion2() {
StringBuilder sb = new StringBuilder();
sb.append("select s from 1,2,3");
OQL.union(sb, "select s from 17,23");
assertEquals("select s from 1,2,3,17,23", sb.toString());
}
@Test
public void testOQLunion3() {
StringBuilder sb = new StringBuilder();
sb.append("select s from 0");
for (int i = 1; i < 200000; ++i) {
sb.append(", ").append(i);
}
sb.append(" s");
OQL.union(sb, "select s from 17,23 s");
assertTrue(sb.toString(), sb.toString().endsWith("17,23 s"));
}
@Test
public void testOQLunion4() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 20000; ++i) {
OQL.union(sb, ("select s from "+i+" s"));
}
assertEquals(-1, sb.indexOf("UNION"));
assertTrue(sb.length() < 20000 * 10);
}
@Test
public void testOQLunion5() {
StringBuilder sb = new StringBuilder();
sb.append("select s from 1,2,3 s");
OQL.union(sb, "select s from 17,23 t");
assertEquals("select s from 1,2,3 s UNION (select s from 17,23 t)", sb.toString());
}
@Test
public void testOQLunion6() {
StringBuilder sb = new StringBuilder();
sb.append("select s from 1 s");
OQL.union(sb, "select s from 2 s");
OQL.union(sb, "select t from 17 t");
OQL.union(sb, "select t from 23 t");
OQL.union(sb, "select s from 3 s");
assertEquals("select s from 1,2,3 s UNION (select t from 17,23 t)", sb.toString());
}
@Test
public void testOQLunion7() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
StringBuilder sb = new StringBuilder();
sb.append("SELECT a.t.s.value FROM OBJECTS (SELECT * FROM OBJECTS ( SELECT (SELECT ${snapshot}.getObject(2839) AS s FROM OBJECTS ( null ) ) AS t FROM OBJECTS ( null ) a ) a ) a");
OQL.union(sb, "SELECT a.t.s.value FROM OBJECTS (SELECT * FROM OBJECTS ( SELECT (SELECT ${snapshot}.getObject(2896) AS s FROM OBJECTS ( null ) ) AS t FROM OBJECTS ( null ) a ) a ) a");
OQL.union(sb, "SELECT a.t.s.value FROM OBJECTS (SELECT * FROM OBJECTS ( SELECT (SELECT ${snapshot}.getObject(2796) AS s FROM OBJECTS ( null ) ) AS t FROM OBJECTS ( null ) a ) a ) a");
String s1 = sb.toString();
assertThat(s1, containsString("2839"));
assertThat(s1, containsString("2896"));
assertThat(s1, containsString("2796"));
IResultTable irt = (IResultTable)execute(s1, dump);
assertThat(irt.getRowCount(), equalTo(3));
checkGetOQL(irt, dump);
}
/**
* Complex test to check that the second FROM clause is reevaluated.
* @throws SnapshotException
*/
@Test
public void testComplex1() throws SnapshotException {
int res[] = (int[])execute("SELECT OBJECTS r from OBJECTS ${snapshot}.@GCRoots r "
+ " WHERE (SELECT s FROM OBJECTS ${snapshot}.getGCRootInfo(r) s WHERE s.@type = 8) != null");
assertEquals(23, res.length);
}
/**
* Complex test to check that the second FROM clause inside a UNION is reevaluated.
* @throws SnapshotException
*/
@Test
public void testComplex2() throws SnapshotException {
int res[] = (int[])execute("SELECT OBJECTS r from OBJECTS ${snapshot}.@GCRoots r "
+ " WHERE (SELECT s FROM dummy s UNION (SELECT s FROM OBJECTS ${snapshot}.getGCRootInfo(r) s WHERE s.@type = 8)) != null");
assertEquals(23, res.length);
}
/**
* Complex test to check that the second and third FROM clause
* is not reevaluated each time - otherwise this will take a long time.
* @throws SnapshotException
*/
@Test
public void testComplex3() throws SnapshotException {
int res[] = (int[])execute("SELECT OBJECTS r from OBJECTS ${snapshot}.@GCRoots r "
+ "WHERE (SELECT s FROM INSTANCEOF java.lang.Object s "
+ "WHERE (SELECT t FROM INSTANCEOF java.lang.String t) != null) != null");
assertEquals(354, res.length);
}
@Test
public void testComplex4() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT s AS HashMap, eval((SELECT t, t.getKey(), t.getValue() as value "
+ "FROM OBJECTS ( s[0:-1] ) t "
+ "WHERE (toString(t.getKey()) = \"META-INF\")))[0].value AS \"Value for META-INF\" "
+ "FROM java.util.HashMap s "
+ "WHERE "
+ "((SELECT t FROM OBJECTS ( s[0:-1] ) t "
+ "WHERE (toString(t.getKey()) = \"META-INF\")) != null)");
assertEquals(3, irt.getRowCount());
// 0 is the whole row, 1 is column 0, 2 is column 1
assertEquals("Value for META-INF", irt.getResultMetaData().getContextProviders().get(2).getLabel());
int id = irt.getResultMetaData().getContextProviders().get(1).getContext(irt.getRow(0)).getObjectId();
assertTrue(id >= 0);
checkGetOQL(irt);
}
@Test
public void testComplex5() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT v.t, v.get(\"t[0:-1]\")[0].getKey(), v.t[0:-1], v.get(\"t[0:-1]\") "
+ "FROM OBJECTS ( "
+ "eval((" // Avoid auto-flattening
+ "SELECT t, t[0:-1] "
+ "FROM java.util.HashSet t "
+ "UNION "
+ "( SELECT s, s[0:-1] "
+ "FROM java.util.Hashtable s ) )"
+ "))"
+ " v ");
assertEquals(11, irt.getRowCount());
checkGetOQL(irt);
}
@Test
public void testComplex5a() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT v.t, v.get(\"t[0:-1]\")[0].getKey(), v.t[0:-1], v.get(\"t[0:-1]\") "
+ "FROM OBJECTS ( "
+ "eval((" // Avoid auto-flattening
+ "SELECT t, t[0:-1] "
+ "FROM java.util.HashSet t )"
+ "))"
+ " v");
assertEquals(5, irt.getRowCount());
checkGetOQL(irt);
}
@Test
public void testComplex5b() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT map, map[0:-1] "
+ "FROM OBJECTS ( SELECT * FROM java.util.HashSet t )");
assertEquals(5, irt.getRowCount());
checkGetOQL(irt);
}
@Test
public void testComplex5c() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT v.t, v.get(\"t[0:-1]\")[0].getKey(), v.t[0:-1], v.get(\"t[0:-1]\") "
+ "FROM OBJECTS ( "
+ "eval((" // Avoid auto-flattening
+ "SELECT t, t[0:-1] "
+ "FROM java.util.HashSet t )"
+ "))"
+ " v "
+ "UNION ("
+ "SELECT v.t, v.get(\"t[0:-1]\")[0].getKey(), v.t[0:-1], v.get(\"t[0:-1]\") "
+ "FROM OBJECTS ("
+ "eval((" // Avoid auto-flattening
+ "SELECT t, t[0:-1] FROM java.util.Hashtable t )"
+ "))"
+ " v )");
assertEquals(11, irt.getRowCount());
checkGetOQL(irt);
}
@Test
public void testComplex5d() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT v, v[0:-1][0].getKey(), v[0:-1] "
+ "FROM OBJECTS ( "
+ "SELECT * FROM java.util.HashSet t ) v "
+ "UNION "
+ "(SELECT v, v[0:-1][0].getKey(), v[0:-1] "
+ "FROM OBJECTS "
+ "( SELECT * FROM java.util.Hashtable t ) v )");
assertEquals(11, irt.getRowCount());
checkGetOQL(irt);
}
@Test
public void testComplex6() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT toString(v[0].getKey()) AS Key "
+ "FROM OBJECTS "
+ "( SELECT * "
+ "FROM java.util.HashSet t "
+ "UNION "
+ "( SELECT * "
+ "FROM java.util.Hashtable s ) ) v ");
assertEquals(11, irt.getRowCount());
assertEquals("META-INF", irt.getColumnValue(irt.getRow(1), 0));
checkGetOQL(irt);
}
@Test
public void testComplex7() throws SnapshotException {
Object result = execute("select * from OBJECTS (SELECT * FROM OBJECTS ( SELECT s.table, s.@usedHeapSize, s[0:-1], s.@objectId, s.@usedHeapSize FROM java.util.HashMap s WHERE (s.table != null) ) z)");
assertNotNull(result);
}
/**
* Check select item is reevaluated as sub-select is context dependent
* @throws SnapshotException
*/
@Test
public void testComplex8() throws SnapshotException {
int r1[] = (int[])execute("SELECT OBJECTS ( SELECT OBJECTS q.getKey() AS k FROM OBJECTS ( t[0:-1] ) q ) FROM java.util.HashMap t");
int r2[] = (int[])execute("SELECT OBJECTS (SELECT * FROM OBJECTS ( SELECT OBJECTS q.getKey() AS k FROM OBJECTS ( t[0:-1] ) q ) ) FROM java.util.HashMap t");
assertEquals("Context dependent subselect", r1.length, r2.length);
}
@Test
public void testComplex9() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT m AS map, classof(m).@name AS type, m[0:-1].size() AS size, (SELECT OBJECTS z.getKey() FROM OBJECTS ( m[0:-1] ) z ) AS keys, (SELECT OBJECTS z.getValue() FROM OBJECTS ( m[0:-1] ) z ) AS values FROM INSTANCEOF java.util.AbstractMap m ");
// 3 columns plus base row have context providers
assertEquals(4, irt.getResultMetaData().getContextProviders().size());
checkGetOQL(irt);
}
@Test
public void testComplex10() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT z.map AS Map, z.kv.key AS Key, z.kv.value AS Value FROM OBJECTS ( SELECT h AS map, (SELECT e.getKey() AS key, e.getValue() AS value FROM OBJECTS ${h}[0:-1] e ) AS kv FROM java.util.HashMap h ) z WHERE (z.kv.key != null)");
assertThat(irt.getRowCount(), greaterThan(0));
assertThat(irt.getColumns().length, equalTo(3));
checkGetOQL(irt);
}
@Test
public void testComplex11() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT 'c', \"String\", 1, 1234567890123456789L, 1.23456, 1.23456F, 1.23456789, 1.23456789D, true, false, null FROM OBJECTS 0");
assertThat(irt.getRowCount(), equalTo(1));
assertThat(irt.getColumns().length, equalTo(11));
Object row = irt.getRow(0);
assertNotNull(row);
checkGetOQL(irt);
}
@Test
public void testComplex12() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT 'c' as a, \"String\" as b, 1 as c, 1234567890123456789L as d, 1.23456 as e, 1.23456F as f, 1.23456789 as g, 1.23456789D as h, true as i, false as j, null as k FROM OBJECTS 0");
assertThat(irt.getRowCount(), equalTo(1));
assertThat(irt.getColumns().length, equalTo(11));
Object row = irt.getRow(0);
assertNotNull(row);
checkGetOQL(irt);
}
@Test
public void testComplex13() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT z.a,z.b,z.c,z.d,z.e,z.f,z.g,z.h,z.i,z.j,z.k FROM OBJECTS ("
+ "SELECT 'c' as a, \"String\" as b, 1 as c, 1234567890123456789L as d, 1.23456 as e, 1.23456F as f, 1.23456789 as g, 1.23456789D as h, true as i, false as j, null as k FROM OBJECTS 0"
+ ") z");
assertThat(irt.getRowCount(), equalTo(1));
assertThat(irt.getColumns().length, equalTo(11));
Object row = irt.getRow(0);
assertNotNull(row);
checkGetOQL(irt);
}
@Test
public void testComplex14() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT "
+ "(SELECT * FROM OBJECTS ('c')) as a, "
+ "(SELECT * FROM OBJECTS (\"String\")) as b, "
+ "(SELECT * FROM OBJECTS (1)) as c, "
+ "(SELECT * FROM OBJECTS (1234567890123456789L)) as d, "
+ "(SELECT * FROM OBJECTS (1.23456)) as e, "
+ "(SELECT * FROM OBJECTS (1.23456F)) as f, "
+ "(SELECT * FROM OBJECTS (1.23456789)) as g, "
+ "(SELECT * FROM OBJECTS (1.23456789D)) as h, "
+ "(SELECT * FROM OBJECTS (true)) as i, "
+ "(SELECT * FROM OBJECTS (false)) as j, "
+ "(SELECT * FROM OBJECTS (null)) as k"
+ " FROM OBJECTS 0");
assertThat(irt.getRowCount(), equalTo(1));
assertThat(irt.getColumns().length, equalTo(11));
Object row = irt.getRow(0);
assertNotNull(row);
checkGetOQL(irt);
}
@Test
public void testComplex15() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT a.t.s.value, a, outbounds(a.t.s.value) "
+ "FROM OBJECTS ( "
+ "SELECT "
+ "(SELECT s FROM java.lang.String s ) AS t "
+ "FROM OBJECTS ( \"A\" ) ) a");
assertThat(irt.getColumns().length, equalTo(3));
checkGetOQL(irt);
}
@Test
public void testComplex16() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT a.t.s.value, a, outbounds(a.t.s.value) "
+ "FROM OBJECTS ( "
+ "SELECT "
+ "(SELECT s FROM java.lang.String s ) AS t "
+ "FROM OBJECTS ( \"A\" ) ) a "
+ "UNION ("
+ "SELECT a.t.s.value, a, outbounds(a.t.s.value) "
+ "FROM OBJECTS ( "
+ "SELECT "
+ "(SELECT s FROM java.lang.String s ) AS t "
+ "FROM OBJECTS ( \"A\" ) ) a )");
assertThat(irt.getColumns().length, equalTo(3));
checkGetOQL(irt);
}
/**
* check a column holding objects and ints
*/
@Test
public void testComplex17() throws SnapshotException {
IResultTable irt = (IResultTable)execute("SELECT v, v.i.value FROM OBJECTS ( SELECT i FROM java.lang.String i UNION ( SELECT i FROM java.lang.Integer i ) ) v");
assertThat(irt.getColumns().length, equalTo(2));
checkGetOQL(irt);
}
/**
* Cross Join.
* Integer and Boolean
* takes too long with Integer and Long
* @throws SnapshotException
*/
@Test
public void testCrossJoin() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
int ints[] = (int[])execute("SELECT * from java.lang.Integer", dump);
assertNotNull(ints);
int bools[] = (int[])execute("SELECT * from java.lang.Boolean", dump);
assertNotNull(bools);
IResultTable irt = (IResultTable)execute("SELECT z.i AS Integer, z.i.value AS \"Integer value\", z.lv.l AS Boolean, z.lv.l.value as \"Boolean value\" \r\n" +
"FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Boolean l ) AS lv FROM java.lang.Integer i ) z", dump);
assertThat(irt.getRowCount(), equalTo(ints.length * bools.length));
for (int i = 0; i < irt.getRowCount(); ++i) {
Object row = irt.getRow(i);
Object iv1 = irt.getColumnValue(row, 1);
assertThat(iv1, instanceOf(Integer.class));
Object iv2 = irt.getColumnValue(row, 3);
assertThat(iv2, instanceOf(Boolean.class));
}
checkGetOQL(irt, dump);
}
@Test
public void testLeftJoin() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
int ints[] = (int[])execute("SELECT * from java.lang.Integer", dump);
assertNotNull(ints);
int longs[] = (int[])execute("SELECT * from java.lang.Long", dump);
assertNotNull(longs);
IResultTable irt = (IResultTable)execute("SELECT z.i AS Integer, z.i.value AS \"Integer value\", z.lv.l AS Long, z.lv.l.value as \"Long value\" \r\n" +
"FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l WHERE (l.value = i.value)) AS lv FROM java.lang.Integer i ) z", dump);
assertThat(irt.getRowCount(), greaterThanOrEqualTo(ints.length));
for (int i = 0; i < irt.getRowCount(); ++i) {
Object row = irt.getRow(i);
Object iv1 = irt.getColumnValue(row, 1);
assertThat(iv1, instanceOf(Integer.class));
Object iv2 = irt.getColumnValue(row, 3);
assertThat(iv2, anyOf(nullValue(),instanceOf(Long.class)));
if (iv2 != null)
assertThat((long)(Integer)iv1, equalTo(iv2));
}
checkGetOQL(irt, dump);
}
@Test
public void testInnerJoin1() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
int ints[] = (int[])execute("SELECT * from java.lang.Integer", dump);
assertNotNull(ints);
int longs[] = (int[])execute("SELECT * from java.lang.Long", dump);
assertNotNull(longs);
IResultTable irt = (IResultTable)execute("SELECT z.i AS Integer, z.i.value AS \"Integer value\", z.lv.l AS Long, z.lv.l.value as \"Long value\" \r\n" +
"FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l WHERE (l.value = i.value)) AS lv FROM java.lang.Integer i ) z WHERE (z.lv != null)", dump);
assertThat(irt.getRowCount(), lessThanOrEqualTo(ints.length));
assertThat(irt.getRowCount(), lessThanOrEqualTo(longs.length));
for (int i = 0; i < irt.getRowCount(); ++i) {
Object row = irt.getRow(i);
Object iv1 = irt.getColumnValue(row, 1);
assertThat(iv1, instanceOf(Integer.class));
Object iv2 = irt.getColumnValue(row, 3);
assertThat(iv2, instanceOf(Long.class));
assertThat((long)(Integer)iv1, equalTo(iv2));
}
checkGetOQL(irt, dump);
}
@Test
public void testInnerJoin2() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
int ints[] = (int[])execute("SELECT * from java.lang.Integer", dump);
assertNotNull(ints);
int longs[] = (int[])execute("SELECT * from java.lang.Long", dump);
assertNotNull(longs);
IResultTable irt = (IResultTable)execute("SELECT z.iv.i AS Integer, z.iv.i.value AS \"Integer value\", z.l AS Long, z.l.value as \"Long value\" \r\n" +
"FROM OBJECTS ( SELECT (SELECT i FROM java.lang.Integer i WHERE (i.value = l.value)) AS iv, l FROM java.lang.Long l ) z WHERE (z.iv != null)", dump);
assertThat(irt.getRowCount(), lessThanOrEqualTo(ints.length));
assertThat(irt.getRowCount(), lessThanOrEqualTo(longs.length));
for (int i = 0; i < irt.getRowCount(); ++i) {
Object row = irt.getRow(i);
Object iv1 = irt.getColumnValue(row, 1);
assertThat(iv1, instanceOf(Integer.class));
Object iv2 = irt.getColumnValue(row, 3);
assertThat(iv2, instanceOf(Long.class));
assertThat((long)(Integer)iv1, equalTo(iv2));
}
checkGetOQL(irt, dump);
}
@Test
public void testRightJoin() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
int ints[] = (int[])execute("SELECT * from java.lang.Integer", dump);
assertNotNull(ints);
int longs[] = (int[])execute("SELECT * from java.lang.Long", dump);
assertNotNull(longs);
IResultTable irt = (IResultTable)execute("SELECT z.iv.i AS Integer, z.iv.i.value AS \"Integer value\", z.l AS Long, z.l.value as \"Long value\" \r\n" +
"FROM OBJECTS ( SELECT (SELECT i FROM java.lang.Integer i WHERE (i.value = l.value)) AS iv, l FROM java.lang.Long l ) z", dump);
assertThat(irt.getRowCount(), greaterThanOrEqualTo(longs.length));
for (int i = 0; i < irt.getRowCount(); ++i) {
Object row = irt.getRow(i);
Object iv1 = irt.getColumnValue(row, 1);
assertThat(iv1, anyOf(nullValue(),instanceOf(Integer.class)));
Object iv2 = irt.getColumnValue(row, 3);
assertThat(iv2, instanceOf(Long.class));
if (iv1 != null)
assertThat((long)(Integer)iv1, equalTo(iv2));
}
checkGetOQL(irt, dump);
}
@Test
public void testFullOuterJoin() throws SnapshotException {
String dump = TestSnapshots.SUN_JDK6_18_32BIT;
int ints[] = (int[])execute("SELECT * from java.lang.Integer", dump);
assertNotNull(ints);
int longs[] = (int[])execute("SELECT * from java.lang.Long", dump);
assertNotNull(longs);
IResultTable irt = (IResultTable)execute("SELECT z.i AS Integer, z.i.value AS \"Integer value\", z.lv.l AS Long, z.lv.l.value as \"Long value\" \r\n" +
"FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l WHERE (l.value = i.value)) AS lv FROM java.lang.Integer i ) z \r\n" +
"UNION (\r\n" +
"SELECT z.iv.i AS Integer, z.iv.i.value AS \"Integer value\", z.l AS Long, z.l.value as \"Long value\" \r\n" +
"FROM OBJECTS ( SELECT (SELECT i FROM java.lang.Integer i WHERE (i.value = l.value)) AS iv, l FROM java.lang.Long l ) z WHERE (z.iv = null)\r\n" +
")", dump);
assertThat(irt.getRowCount(), greaterThanOrEqualTo(ints.length));
assertThat(irt.getRowCount(), greaterThanOrEqualTo(longs.length));
for (int i = 0; i < irt.getRowCount(); ++i) {
Object row = irt.getRow(i);
Object iv1 = irt.getColumnValue(row, 1);
assertThat(iv1, anyOf(nullValue(),instanceOf(Integer.class)));
Object iv2 = irt.getColumnValue(row, 3);
assertThat(iv2, anyOf(nullValue(),instanceOf(Long.class)));
if (iv1 != null && iv2 != null)
assertThat((long)(Integer)iv1, equalTo(iv2));
}
checkGetOQL(irt, dump);
}
/**
* Check all getOQL() from contexts from the result are sensible.
* @param rt ResultTable
* @throws SnapshotException
*/
void checkGetOQL(IResultTable rt) throws SnapshotException
{
checkGetOQL(rt, TestSnapshots.SUN_JDK5_64BIT);
}
/**
* Check all getOQL() from contexts from the result are sensible.
* @param rt ResultTable
* @param dump the snapshot to test against
* @throws SnapshotException
*/
void checkGetOQL(IResultTable rt, String dump) throws SnapshotException
{
// Check the default contextx
for (int i = 0; i < rt.getRowCount(); ++i)
{
IContextObject c = rt.getContext(rt.getRow(i));
checkDefaultContext(rt, i, c, dump);
for (ContextProvider p : rt.getResultMetaData().getContextProviders())
{
if (p.getLabel().startsWith("SELECT ... ")) {
// Default provider as metadata provider
c = p.getContext(rt.getRow(i));
checkDefaultContext(rt, i, c, dump);
}
}
}
// check the other providers
for (ContextProvider p : rt.getResultMetaData().getContextProviders())
{
String l = p.getLabel();
for (int j = 0; j < rt.getColumns().length; ++j) {
if (l.equals(rt.getColumns()[j].getLabel()))
{
// Now check each row
for (int i = 0; i < rt.getRowCount(); ++i)
{
Object o = rt.getColumnValue(rt.getRow(i), j);
if (o instanceof IObject)
{
// SimpleObject
IObject io = (IObject)o;
IContextObject c = p.getContext(rt.getRow(i));
checkSingleObjectContext(io.getObjectId(), c, dump);
}
else if (o instanceof Iterable && ((Iterable<?>)o).iterator().hasNext() && ((Iterable<?>)o).iterator().next() instanceof IObject || o instanceof int[])
{
// Iterable, look for objects
List<IObject> os = new ArrayList<IObject>();
ArrayInt ai = new ArrayInt();
if (o instanceof Iterable<?>)
{
for (Object o1 : (Iterable<?>)o)
{
if (o1 instanceof IObject)
{
ai.add(((IObject)o1).getObjectId());
os.add((IObject)o1);
}
}
}
else
{
int oa[] = (int[])o;
for (int o1 : oa)
{
ai.add(o1);
}
}
IContextObject c = p.getContext(rt.getRow(i));
assertThat("row="+i+" col="+j, c, instanceOf(IContextObjectSet.class));
IContextObjectSet cs = (IContextObjectSet)c;
int []csobjs = cs.getObjectIds();
assertThat("row="+i+" col="+j, csobjs, equalTo(ai.toArray()));
String oql = cs.getOQL();
Object res = execute(oql, dump);
if (res instanceof int[])
{
int r[] = (int[])res;
assertEquals("row="+i+" col="+j, ai.size(), r.length);
for (IteratorInt it = ai.iterator(); it.hasNext(); )
{
int o1 = it.next();
boolean found = false;
for (int ri : r)
{
if (ri == o1)
found = true;
}
assertTrue("row="+i+" col="+j, found);
}
for (int ri : r)
{
boolean found = false;
for (IteratorInt it = ai.iterator(); it.hasNext(); )
{
int o1 = it.next();
if (ri == o1)
found = true;
}
assertTrue("row="+i+" col="+j, found);
}
}
else if (res instanceof IResultTable)
{
IResultTable rt2 = (IResultTable)res;
assertEquals("row="+i+" col="+j, 1, rt2.getRowCount());
assertEquals("row="+i+" col="+j, 1, rt2.getColumns().length);
List<IObject>os2 = new ArrayList<IObject>();
ArrayInt ai2 = new ArrayInt();
for (int r = 0; r < rt2.getRowCount(); ++r)
{
Object o2 = rt2.getColumnValue(rt2.getRow(r), 0);
if (o2 instanceof int[])
{
ai2.addAll((int[])o2);
}
else
{
assertThat(o2, instanceOf(Iterable.class));
for (Object o3 : (Iterable<?>)o2)
{
assertThat(o3, instanceOf(IObject.class));
IObject io2 = (IObject)o3;
assertTrue("row="+i+" col="+j, os.contains(io2));
os2.add(io2);
ai2.add(io2.getObjectId());
}
}
}
if (ai2.isEmpty())
{
for (IObject ox : os)
{
assertTrue(os2.contains(ox));
}
for (IObject ox : os2)
{
assertTrue(os.contains(ox));
}
}
else
{
assertThat(ai.toArray(), equalTo(ai2.toArray()));
}
}
}
}
}
}
}
}
private void checkDefaultContext(IResultTable rt, int row, IContextObject c, String dump) throws SnapshotException
{
if (c instanceof IContextObjectSet)
{
IContextObjectSet cs = (IContextObjectSet)c;
if (cs.getObjectIds().length == 1)
checkSingleObjectContext(rt, row, cs.getObjectIds()[0], c, dump);
else {
int os[] = cs.getObjectIds();
String oql = cs.getOQL();
Object res = execute(oql, dump);
if (res instanceof int[])
{
int r[] = (int[])res;
assertEquals(os.length, r.length);
for (int i = 0; i < os.length; ++i)
{
assertEquals("index="+i, os[i], r[i]);
}
}
else if (res instanceof IResultTable)
{
IResultTable rt2 = (IResultTable)res;
assertEquals("row="+row+" oql="+oql, 1, rt2.getRowCount());
assertEquals("row="+row+" oql="+oql, rt.getColumns().length, rt2.getColumns().length);
for (int j = 0; j < rt.getColumns().length; ++j)
{
Object o1 = rt.getColumnValue(rt.getRow(row), j);
Object o2 = rt2.getColumnValue(rt2.getRow(0), j);
assertThat("row="+row+" col="+j+" oql="+oql, o1, equalTo(o2));
}
IContextObject ic = rt2.getContext(rt2.getRow(0));
assertThat("row="+row+" oql="+oql, ic, instanceOf(IContextObjectSet.class));
IContextObjectSet ics = (IContextObjectSet)ic;
assertEquals("row="+row, oql, ics.getOQL());
assertEquals("row="+row+" oql="+oql ,cs.getObjectId(), ics.getObjectId());
assertEquals("row="+row+" oql="+oql, os.length, ics.getObjectIds().length);
for (int ix = 0; ix < os.length; ++ix)
{
assertEquals("row="+row+" oql="+oql, os[ix], ics.getObjectIds()[ix]);
}
}
}
} else {
// Not everything has a backing object
assertEquals(null, c);
}
}
private void checkSingleObjectContext(int ioid, IContextObject c, String dump) throws SnapshotException
{
assertThat(c, instanceOf(IContextObjectSet.class));
IContextObjectSet cs = (IContextObjectSet)c;
assertEquals(ioid, cs.getObjectId());
assertEquals(1, cs.getObjectIds().length);
assertEquals(ioid, cs.getObjectIds()[0]);
String oql = cs.getOQL();
Object res = execute(oql, dump);
if (res instanceof int[])
{
int r[] = (int[])res;
assertEquals(1, r.length);
assertEquals(ioid, r[0]);
}
else if (res instanceof IResultTable)
{
IResultTable rt2 = (IResultTable)res;
assertEquals(1, rt2.getRowCount());
assertEquals(1, rt2.getColumns().length);
Object o2 = rt2.getColumnValue(rt2.getRow(0), 0);
assertThat(o2, instanceOf(IObject.class));
IObject io2 = (IObject)o2;
assertEquals(ioid, io2.getObjectId());
}
}
private void checkSingleObjectContext(IResultTable rt, int row, int ioid, IContextObject c, String dump) throws SnapshotException
{
assertThat(c, instanceOf(IContextObjectSet.class));
IContextObjectSet cs = (IContextObjectSet)c;
String oql = cs.getOQL();
Object res = execute(oql, dump);
if (res instanceof int[])
{
int r[] = (int[])res;
assertEquals(oql, 1, r.length);
assertEquals(oql, ioid, r[0]);
}
else if (res instanceof IResultTable)
{
IResultTable rt2 = (IResultTable)res;
assertEquals(oql, 1, rt2.getRowCount());
assertEquals(oql, rt.getColumns().length, rt2.getColumns().length);
for (int j = 0; j < rt.getColumns().length; ++j)
{
Object o1 = rt.getColumnValue(rt.getRow(row), j);
Object o2 = rt2.getColumnValue(rt2.getRow(0), j);
if (o1 instanceof int[] && o2 instanceof int[])
assertArrayEquals("Row="+row+" col="+j, (int[])o1, (int[])o2);
else
assertEquals("Row="+row+" col="+j, o1, o2);
}
}
}
/**
* Test that null objects from a from clause don't cause problems
*/
@Test
public void testFromClauseWithNullObjects() throws SnapshotException {
int res[] = (int[])execute("SELECT * FROM java.lang.ThreadGroup s"
+ " WHERE ((SELECT t FROM OBJECTS ( s.threads[0:-1] ) t WHERE t.name.toString().startsWith(\"R\")) != null)");
assertEquals(1, res.length);
}
/**
* Test reading static fields of a class
* @throws SnapshotException
*/
@Test
public void testStatic() throws SnapshotException
{
Object result = execute("select MAX_VALUE from OBJECTS java.lang.Integer");
IResultTable table = (IResultTable) result;
assertThat("1 row expected", table.getRowCount(), equalTo(1));
Object row = table.getRow(0);
int val = (Integer) table.getColumnValue(row, 0);
assertThat("Integer.MAX_VALUE", val, equalTo(Integer.MAX_VALUE));
checkGetOQL(table);
}
/**
* Test extracting objects from a collection
* @throws SnapshotException
*/
@Test
public void testArrayList() throws SnapshotException
{
int objs[] = (int[])execute("select objects s[0:-1] from java.util.ArrayList s");
assertThat("Multiple objects expected", objs.length, greaterThanOrEqualTo(2));
}
/**
* Test extracting objects from a collection.
* Check we can read the last element from a collection.
* @throws SnapshotException
*/
@Test
public void testArrayListGet() throws SnapshotException
{
int objs[] = (int[])execute("select objects s[0:-1][-1:-1][0] from java.util.ArrayList s");
assertThat("Multiple objects expected", objs.length, greaterThanOrEqualTo(2));
}
@Rule
public ExpectedException expectedException = ExpectedException.none();
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallClassLoader() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.ClassLoader\").getSystemClassLoader() FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallCompiler() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.Compiler\").disable() FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallProcess() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.ProcessBuilder\").getConstructor(s.@class.forName(\"[Ljava.lang.String;\")).newInstance(\"calc\") FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallRuntime() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.Runtime\").getRuntime() FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallSecurityManager() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.SecurityManager\").newInstance().checkExec(\"calc\") FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallSystem() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.System\").currentTimeMillis() FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls disallowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallThread() throws SnapshotException
{
expectedException.expectCause(isA(java.security.AccessControlException.class));
Object o = execute("SELECT s.@class.forName(\"java.lang.Thread\").activeCount() FROM OBJECTS 1 s");
assertNull(o);
}
/**
* Test method calls allowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallInteger() throws SnapshotException
{
Object result = execute("SELECT eval(123).intValue() FROM OBJECTS 1 s");
assertThat(result, instanceOf(IResultTable.class));
IResultTable table = (IResultTable) result;
Object row = table.getRow(1);
assertThat(table.getColumnValue(row, 0), equalTo((Object)123));
}
/**
* Test method calls allowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallVarArgs1() throws SnapshotException
{
Object result = execute("SELECT s.@class.forName(\"java.util.Arrays\").asList(1) FROM OBJECTS 1 s");
assertThat(result, instanceOf(IResultTable.class));
IResultTable table = (IResultTable) result;
Object row = table.getRow(0);
Object item = table.getColumnValue(row, 0);
assertThat(item, instanceOf(List.class));
List<?> al = (List<?>)item;
assertThat(al.size(), equalTo(1));
}
/**
* Test method calls allowed.
* @throws SnapshotException
*/
@Test
public void testMethodCallVarArgs5() throws SnapshotException
{
Object result = execute("SELECT s.@class.forName(\"java.util.Arrays\").asList(1,2,3,4,5) FROM OBJECTS 1 s");
assertThat(result, instanceOf(IResultTable.class));
IResultTable table = (IResultTable) result;
Object row = table.getRow(0);
Object item = table.getColumnValue(row, 0);
assertThat(item, instanceOf(List.class));
List<?> al = (List<?>)item;
assertThat(al.size(), equalTo(5));
}
// //////////////////////////////////////////////////////////////
// internal helpers
// //////////////////////////////////////////////////////////////
/**
* Use to check that the work reports from OQL processing are sensible.
*/
static class CountListener extends VoidProgressListener
{
int work;
int done;
public void beginTask(String name, int totalWork)
{
work = totalWork;
}
public void done()
{
if (done < work)
done = work;
}
public void worked(int work)
{
if (done + work > this.work)
throw new IllegalArgumentException("Too much work "+work+" for a listener "+done+"/"+this.work);
done += work;
}
}
private Object execute(String oql) throws SnapshotException
{
return execute(oql, TestSnapshots.SUN_JDK5_64BIT);
}
private Object execute(String oql, String snapshotName) throws SnapshotException
{
try
{
ISnapshot snapshot = TestSnapshots.getSnapshot(snapshotName, false);
IOQLQuery query = SnapshotFactory.createQuery(oql);
CountListener cl = new CountListener();
Object ret = query.execute(snapshot, cl);
assertThat(oql, cl.done, equalTo(cl.work));
return ret;
}
catch (OQLParseException e)
{
throw new SnapshotException("Error while parsing: " + oql, e);
}
}
}