/*******************************************************************************
* Copyright (c) 2011 IBM Corporation 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.debug.tests.core;
import org.eclipse.debug.core.model.ILineBreakpoint;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.debug.core.IJavaThread;
import org.eclipse.jdt.debug.eval.IEvaluationResult;
import org.eclipse.jdt.debug.tests.AbstractDebugTest;
import org.eclipse.jdt.internal.debug.core.model.JDIPrimitiveValue;
/**
* Tests that the new forms allowed in literals in Java 7 work as expected
*
* @since 3.1.200
*/
public class LiteralTests17 extends AbstractDebugTest {
public static final String LITERAL_TYPE_NAME = "Literals17";
/**
* Constructor
*/
public LiteralTests17() {
super("Tests for Java 1.7 literal support in evaluations");
}
/* (non-Javadoc)
* @see org.eclipse.jdt.debug.tests.AbstractDebugTest#getProjectContext()
*/
@Override
protected IJavaProject getProjectContext() {
return get17Project();
}
/**
* Perform the evaluation on the given snippet and return the value
* @param snippet
* @return returns the evaluation value or <code>null</code>
* @throws Exception
*/
IValue doEval(String snippet) throws Exception {
ILineBreakpoint bp = createLineBreakpoint(25, LITERAL_TYPE_NAME);
IJavaThread thread = null;
try {
thread = launchToLineBreakpoint(LITERAL_TYPE_NAME, bp);
IEvaluationResult result = evaluate(snippet, thread);
assertNotNull("There must be an evaluation result", result);
assertTrue("There must be no errors in the result", !result.hasErrors());
return result.getValue();
}
finally {
terminateAndRemove(thread);
removeAllBreakpoints();
}
}
/**
* Runs evaluations on the two given snippets returning the value from the second snippet. This method allows us to
* run two snippets on the same thread where the second snippet may or may not depend on the state change from the
* first snippet
*
* @param snippet
* @param snippet2
* @return the {@link IEvaluationResult}
* @throws Exception
*/
IValue doEval(String snippet, String snippet2) throws Exception {
ILineBreakpoint bp = createLineBreakpoint(25, LITERAL_TYPE_NAME);
IJavaThread thread = null;
try {
thread = launchToLineBreakpoint(LITERAL_TYPE_NAME, bp);
IEvaluationResult result = evaluate(snippet, thread);
assertNotNull("There must be an evaluation result", result);
assertTrue("There must be no errors in the result", !result.hasErrors());
result = evaluate(snippet2, thread);
assertNotNull("There must be an evaluation result", result);
assertTrue("There must be no errors in the result", !result.hasErrors());
return result.getValue();
}
finally {
terminateAndRemove(thread);
removeAllBreakpoints();
}
}
/**
* Tests that an addition evaluation with an int with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreIntEval() throws Exception {
IValue value = doEval("literals.x1 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 11", val.getIntValue() == 11);
}
/**
* Tests that we can assign a variable value to an int with underscores
*
* @throws Exception
*/
public void testUnderscoreIntVarAssignment() throws Exception {
IValue value = doEval("literals.x1 = 1_______1;", "literals.x1 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 12", val.getIntValue() == 12);
}
/**
* Tests that an addition evaluation with a short with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreShortEval() throws Exception {
IValue value = doEval("literals.x9 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new short value should be 11", val.getShortValue() == 11);
}
/**
* Tests that we can assign a variable value to a short with underscores
*
* @throws Exception
*/
public void testUnderscoreShortVarAssignment() throws Exception {
IValue value = doEval("literals.x9 = 1_______1;", "literals.x9 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new short value should be 12", val.getShortValue() == 12);
}
/**
* Tests that an addition evaluation with a byte with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreByteEval() throws Exception {
IValue value = doEval("literals.x10 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new byte value should be 9", val.getByteValue() == 9);
}
/**
* Tests that we can assign a variable value to a short with underscores
*
* @throws Exception
*/
public void testUnderscoreByteVarAssignment() throws Exception {
IValue value = doEval("literals.x10 = 1_______1;", "literals.x10 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new byte value should be 12", val.getByteValue() == 12);
}
/**
* Tests that an addition evaluation with a long with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreLongEval() throws Exception {
IValue value = doEval("literals.x8 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new long value should be 11", val.getLongValue() == 11);
}
/**
* Tests that we can assign a variable value to a long with underscores
*
* @throws Exception
*/
public void testUnderscoreLongVarAssignment() throws Exception {
IValue value = doEval("literals.x8 = 1_______1L;", "literals.x8 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new long value should be 12", val.getLongValue() == 12);
}
/**
* Tests that an addition evaluation with a float with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreFloatEval() throws Exception {
IValue value = doEval("literals.x6 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new float value should be 4.1415", val.getFloatValue() == 4.1415F);
}
/**
* Tests that we can assign a variable value to a float with underscores
*
* @throws Exception
*/
public void testUnderscoreFloatVarAssignment() throws Exception {
IValue value = doEval("literals.x6 = 6.1_4_1_5F;", "literals.x6 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new float value should be 7.1415", val.getFloatValue() == 7.1415F);
}
/**
* Tests that an addition evaluation with a double with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreDoubleEval() throws Exception {
IValue value = doEval("literals.x5 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new double value should be 11.556", val.getDoubleValue() == 11.556D);
}
/**
* Tests that we can assign a variable value to a double with underscores
*
* @throws Exception
*/
public void testUnderscoreDoubleVarAssignment() throws Exception {
IValue value = doEval("literals.x5 = 1_5.5_5_6D;", "literals.x5 + 1.000D");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new double value should be 16.556", val.getDoubleValue() == 16.555999999999997D);
}
/**
* Tests that an addition evaluation with a binary literal with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreBinaryEval() throws Exception {
IValue value = doEval("literals.x4 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 9", val.getIntValue() == 9);
}
/**
* Tests that we can assign a variable value to a binary literal with underscores
*
* @throws Exception
*/
public void testUnderscoreBinaryVarAssignment() throws Exception {
IValue value = doEval("literals.x4 = 0b1_0_0_0_0;", "literals.x4 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 17", val.getIntValue() == 17);
}
/**
* Tests that an addition evaluation with a hex with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreHexEval() throws Exception {
IValue value = doEval("literals.x2 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 17", val.getIntValue() == 17);
}
/**
* Tests that we can assign a variable value to a hex with underscores
*
* @throws Exception
*/
public void testUnderscoreHexVarAssignment() throws Exception {
IValue value = doEval("literals.x2 = 0x1_0_0;", "literals.x2 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 257", val.getIntValue() == 257);
}
/**
* Tests that an addition evaluation with an octal with underscores in it works
*
* @throws Exception
*/
public void testUnderscoreOctEval() throws Exception {
IValue value = doEval("literals.x3 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 9", val.getIntValue() == 9);
}
/**
* Tests that we can assign a variable value to an octal with underscores
*
* @throws Exception
*/
public void testUnderscoreOctVarAssignment() throws Exception {
IValue value = doEval("literals.x3 = 0_100;", "literals.x3 + 1");
assertNotNull("The value should not be null", value);
assertTrue("The underlying value must be a primitive value", value instanceof JDIPrimitiveValue);
JDIPrimitiveValue val = (JDIPrimitiveValue) value;
assertTrue("The new integer value should be 65", val.getIntValue() == 65);
}
}