@Test
public void testBug457779_03() {
final IFeatureCallArguments arguments =
this.toArgumentsWithReceiver("String s, int[] i", "\"\"");
final XExpression first = arguments.getArgument(0);
Assert.assertNull(first);
final LightweightTypeReference firstType = arguments.getDeclaredTypeForLambda(0);
Assert.assertNull(firstType);
final XExpression second = arguments.getArgument(1);
Assert.assertTrue((second instanceof XStringLiteral));
final LightweightTypeReference secondType = arguments.getDeclaredTypeForLambda(1);
String _simpleName = secondType.getSimpleName();
Assert.assertEquals("String", _simpleName);
try {
arguments.getArgument(2);
Assert.fail("Expected exception");
} catch (final Throwable _t) {
if (_t instanceof IndexOutOfBoundsException) {
final IndexOutOfBoundsException expected = (IndexOutOfBoundsException) _t;
} else {
throw Exceptions.sneakyThrow(_t);
}
}
try {
arguments.getDeclaredTypeForLambda(2);
Assert.fail("Expected exception");
} catch (final Throwable _t_1) {
if (_t_1 instanceof IndexOutOfBoundsException) {
final IndexOutOfBoundsException expected_1 = (IndexOutOfBoundsException) _t_1;
} else {
throw Exceptions.sneakyThrow(_t_1);
}
}
}
@Test
public void test_08() {
final IFeatureCallArguments arguments =
this.toArgumentsWithReceiver("String s, int i", "\"\", 1");
int _argumentCount = arguments.getArgumentCount();
Assert.assertEquals(3, _argumentCount);
boolean _hasUnprocessedArguments = arguments.hasUnprocessedArguments();
Assert.assertTrue(_hasUnprocessedArguments);
final IFeatureCallArgumentSlot firstSlot = arguments.getNextUnprocessedArgumentSlot();
boolean _isVarArg = firstSlot.isVarArg();
Assert.assertFalse(_isVarArg);
boolean _isSuperfluous = firstSlot.isSuperfluous();
Assert.assertFalse(_isSuperfluous);
XExpression _argumentExpression = firstSlot.getArgumentExpression();
Assert.assertTrue((_argumentExpression instanceof XStringLiteral));
LightweightTypeReference _declaredType = firstSlot.getDeclaredType();
String _simpleName = _declaredType.getSimpleName();
Assert.assertEquals("String", _simpleName);
boolean _isProcessed = arguments.isProcessed(0);
Assert.assertTrue(_isProcessed);
boolean _isProcessed_1 = arguments.isProcessed(1);
Assert.assertFalse(_isProcessed_1);
firstSlot.markProcessed();
boolean _isProcessed_2 = arguments.isProcessed(1);
Assert.assertTrue(_isProcessed_2);
boolean _hasUnprocessedArguments_1 = arguments.hasUnprocessedArguments();
Assert.assertTrue(_hasUnprocessedArguments_1);
final IFeatureCallArgumentSlot secondSlot = arguments.getNextUnprocessedArgumentSlot();
boolean _isVarArg_1 = secondSlot.isVarArg();
Assert.assertTrue(_isVarArg_1);
boolean _isSuperfluous_1 = secondSlot.isSuperfluous();
Assert.assertFalse(_isSuperfluous_1);
XExpression _argumentExpression_1 = secondSlot.getArgumentExpression();
Assert.assertTrue((_argumentExpression_1 instanceof XNumberLiteral));
LightweightTypeReference _declaredType_1 = secondSlot.getDeclaredType();
String _simpleName_1 = _declaredType_1.getSimpleName();
Assert.assertEquals("int", _simpleName_1);
boolean _isProcessed_3 = arguments.isProcessed(2);
Assert.assertFalse(_isProcessed_3);
secondSlot.markProcessed();
boolean _isProcessed_4 = arguments.isProcessed(2);
Assert.assertTrue(_isProcessed_4);
boolean _hasUnprocessedArguments_2 = arguments.hasUnprocessedArguments();
Assert.assertFalse(_hasUnprocessedArguments_2);
}
@Test
public void test_03() {
final IFeatureCallArguments arguments = this.toArgumentsWithoutReceiver("String s", "\"\"");
boolean _hasUnprocessedArguments = arguments.hasUnprocessedArguments();
Assert.assertTrue(_hasUnprocessedArguments);
int _argumentCount = arguments.getArgumentCount();
Assert.assertEquals(1, _argumentCount);
final IFeatureCallArgumentSlot singleSlot = arguments.getNextUnprocessedArgumentSlot();
boolean _isVarArg = singleSlot.isVarArg();
Assert.assertTrue(_isVarArg);
boolean _isSuperfluous = singleSlot.isSuperfluous();
Assert.assertFalse(_isSuperfluous);
XExpression _argumentExpression = singleSlot.getArgumentExpression();
Assert.assertTrue((_argumentExpression instanceof XStringLiteral));
LightweightTypeReference _declaredType = singleSlot.getDeclaredType();
String _simpleName = _declaredType.getSimpleName();
Assert.assertEquals("String", _simpleName);
singleSlot.markProcessed();
boolean _hasUnprocessedArguments_1 = arguments.hasUnprocessedArguments();
Assert.assertFalse(_hasUnprocessedArguments_1);
}
public LightweightTypeReference resolvesTo(final String expression, final String type) {
try {
final XExpression xExpression = this.expression(expression, false);
Resource _eResource = xExpression.eResource();
EList<Diagnostic> _errors = _eResource.getErrors();
String _string = _errors.toString();
Resource _eResource_1 = xExpression.eResource();
EList<Diagnostic> _errors_1 = _eResource_1.getErrors();
boolean _isEmpty = _errors_1.isEmpty();
Assert.assertTrue(_string, _isEmpty);
Resource _eResource_2 = xExpression.eResource();
EList<Diagnostic> _warnings = _eResource_2.getWarnings();
String _string_1 = _warnings.toString();
Resource _eResource_3 = xExpression.eResource();
EList<Diagnostic> _warnings_1 = _eResource_3.getWarnings();
boolean _isEmpty_1 = _warnings_1.isEmpty();
Assert.assertTrue(_string_1, _isEmpty_1);
IBatchTypeResolver _typeResolver = this.getTypeResolver();
final IResolvedTypes resolvedTypes = _typeResolver.resolveTypes(xExpression);
final LightweightTypeReference resolvedType = resolvedTypes.getActualType(xExpression);
String _simpleName = resolvedType.getSimpleName();
Assert.assertEquals(type, _simpleName);
TreeIterator<EObject> _eAllContents = xExpression.eAllContents();
Iterable<EObject> _iterable = IteratorExtensions.<EObject>toIterable(_eAllContents);
for (final EObject content : _iterable) {
boolean _matched = false;
if (!_matched) {
if (content instanceof XSwitchExpression) {
final XSwitchExpression _xSwitchExpression = (XSwitchExpression) content;
_matched = true;
this.assertExpressionTypeIsResolved(_xSwitchExpression, resolvedTypes);
String _localVarName = _xSwitchExpression.getLocalVarName();
boolean _notEquals = (!Objects.equal(_localVarName, null));
if (_notEquals) {
this.assertIdentifiableTypeIsResolved(_xSwitchExpression, resolvedTypes);
}
}
}
if (!_matched) {
if (content instanceof XAbstractFeatureCall) {
final XAbstractFeatureCall _xAbstractFeatureCall = (XAbstractFeatureCall) content;
_matched = true;
this.assertExpressionTypeIsResolved(_xAbstractFeatureCall, resolvedTypes);
XExpression _implicitReceiver = _xAbstractFeatureCall.getImplicitReceiver();
boolean _notEquals = (!Objects.equal(_implicitReceiver, null));
if (_notEquals) {
XExpression _implicitReceiver_1 = _xAbstractFeatureCall.getImplicitReceiver();
this.assertExpressionTypeIsResolved(_implicitReceiver_1, resolvedTypes);
}
}
}
if (!_matched) {
if (content instanceof XExpression) {
final XExpression _xExpression = (XExpression) content;
_matched = true;
this.assertExpressionTypeIsResolved(_xExpression, resolvedTypes);
}
}
if (!_matched) {
if (content instanceof JvmIdentifiableElement) {
final JvmIdentifiableElement _jvmIdentifiableElement = (JvmIdentifiableElement) content;
_matched = true;
this.assertIdentifiableTypeIsResolved(_jvmIdentifiableElement, resolvedTypes);
}
}
}
TreeIterator<EObject> _eAllContents_1 = xExpression.eAllContents();
Iterable<EObject> _iterable_1 = IteratorExtensions.<EObject>toIterable(_eAllContents_1);
for (final EObject content_1 : _iterable_1) {
boolean _matched_1 = false;
if (!_matched_1) {
if (content_1 instanceof XConstructorCall) {
final XConstructorCall _xConstructorCall = (XConstructorCall) content_1;
_matched_1 = true;
Object _eGet = _xConstructorCall.eGet(Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, false);
final InternalEObject constructor = ((InternalEObject) _eGet);
String _string_2 = _xConstructorCall.toString();
Assert.assertNotNull(_string_2, constructor);
String _string_3 = _xConstructorCall.toString();
boolean _eIsProxy = constructor.eIsProxy();
Assert.assertFalse(_string_3, _eIsProxy);
}
}
if (!_matched_1) {
if (content_1 instanceof XAbstractFeatureCall) {
final XAbstractFeatureCall _xAbstractFeatureCall = (XAbstractFeatureCall) content_1;
_matched_1 = true;
Object _eGet =
_xAbstractFeatureCall.eGet(Literals.XABSTRACT_FEATURE_CALL__FEATURE, false);
final InternalEObject feature = ((InternalEObject) _eGet);
String _string_2 = _xAbstractFeatureCall.toString();
Assert.assertNotNull(_string_2, feature);
String _string_3 = _xAbstractFeatureCall.toString();
boolean _eIsProxy = feature.eIsProxy();
Assert.assertFalse(_string_3, _eIsProxy);
XExpression _implicitReceiver = _xAbstractFeatureCall.getImplicitReceiver();
boolean _notEquals = (!Objects.equal(_implicitReceiver, null));
if (_notEquals) {
XExpression _implicitReceiver_1 = _xAbstractFeatureCall.getImplicitReceiver();
Object _eGet_1 =
_implicitReceiver_1.eGet(Literals.XABSTRACT_FEATURE_CALL__FEATURE, false);
final InternalEObject implicitFeature = ((InternalEObject) _eGet_1);
String _string_4 = implicitFeature.toString();
Assert.assertNotNull(_string_4, feature);
String _string_5 = implicitFeature.toString();
boolean _eIsProxy_1 = feature.eIsProxy();
Assert.assertFalse(_string_5, _eIsProxy_1);
}
}
}
}
Resource _eResource_4 = xExpression.eResource();
Iterable<Diagnostic> _linkingAndSyntaxErrors = this.getLinkingAndSyntaxErrors(_eResource_4);
String _string_2 = _linkingAndSyntaxErrors.toString();
Resource _eResource_5 = xExpression.eResource();
Iterable<Diagnostic> _linkingAndSyntaxErrors_1 = this.getLinkingAndSyntaxErrors(_eResource_5);
boolean _isEmpty_2 = IterableExtensions.isEmpty(_linkingAndSyntaxErrors_1);
Assert.assertTrue(_string_2, _isEmpty_2);
Resource _eResource_6 = xExpression.eResource();
EList<Diagnostic> _warnings_2 = _eResource_6.getWarnings();
String _string_3 = _warnings_2.toString();
Resource _eResource_7 = xExpression.eResource();
EList<Diagnostic> _warnings_3 = _eResource_7.getWarnings();
boolean _isEmpty_3 = _warnings_3.isEmpty();
Assert.assertTrue(_string_3, _isEmpty_3);
return resolvedType;
} catch (Throwable _e) {
throw Exceptions.sneakyThrow(_e);
}
}