private CtExecutable<T> getCtExecutable(CtType<?> typeDecl) { if (typeDecl == null) { return null; } CtTypeReference<?>[] arrayParameters = parameters.toArray(new CtTypeReferenceImpl<?>[0]); CtExecutable<T> method = typeDecl.getMethod(getSimpleName(), arrayParameters); if ((method == null) && (typeDecl instanceof CtClass) && this.isConstructor()) { try { CtClass<?> zeClass = (CtClass) typeDecl; CtConstructor<?> constructor = zeClass.getConstructor(arrayParameters); return (CtExecutable<T>) constructor; } catch (ClassCastException e) { Launcher.LOGGER.error(e.getMessage(), e); } } else if (method == null && getSimpleName().startsWith(CtExecutableReference.LAMBDA_NAME_PREFIX)) { final List<CtLambda> elements = typeDecl.getElements(new NamedElementFilter<>(CtLambda.class, getSimpleName())); if (elements.isEmpty()) { return null; } return elements.get(0); } return method; }
for (final CtType inner : type.getElements( new TypeFilter<>(CtType.class))) {
final CtTypeReference<T> reference = t.getReference(); if (reference.isLocalType()) { final List<CtClass<T>> enclosingClasses = t.getElements(new TypeFilter<CtClass<T>>(CtClass.class) { @Override public boolean matches(CtClass<T> element) { final List<CtNewClass> anonymousClasses = t.getElements(new TypeFilter<CtNewClass>(CtNewClass.class) { @Override public boolean matches(CtNewClass element) {
this.imports.add(createImportWithPosition(factory.Type().createTypeMemberWildcardImportReference(klass.getReference()), importRef)); } else { List<CtNamedElement> methodOrFields = klass.getElements(new NamedElementFilter<>(CtNamedElement.class, methodOrFieldName));
@Override public void reset(CtType testClass) { super.reset(testClass); this.existingStrings = this.testClassToBeAmplified.getElements(new TypeFilter<CtLiteral<String>>(CtLiteral.class)) .stream() .filter(element -> element.getValue() != null && element.getValue() instanceof String) .map(CtLiteral::clone) .map(CtLiteral::getValue) .collect(Collectors.toList()); }
final boolean canBeConstructed = (!typeDeclaration.getElements(new TypeFilter<CtConstructor<?>>(CtConstructor.class) {
if (type.getDeclaration() != null) { final List<CtConstructor<?>> constructors = type.getDeclaration() .getElements(new TypeFilter<CtConstructor<?>>(CtConstructor.class) { @Override public boolean matches(CtConstructor<?> element) {
final CtTypeReference classTestReference = classTest.getReference(); currentTestClass.getElements(new TypeFilter<CtTypeReference>(CtTypeReference.class) { @Override public boolean matches(CtTypeReference element) { currentTestClass.getElements(new TypeFilter<CtLiteral>(CtLiteral.class) { @Override public boolean matches(CtLiteral element) {
@Override @SuppressWarnings("unchecked") public CtType<T> getDeclaration() { if (!isPrimitive() && !isAnonymous()) { return (CtType<T>) getFactory().Type().get(getQualifiedName()); } if (!isPrimitive() && isAnonymous()) { final CtType<?> rootType = getFactory().Type().get(getDeclaringType().getQualifiedName()); final CtNewClass elements = rootType.getElements(new AbstractFilter<CtNewClass<?>>(CtNewClass.class) { @Override public boolean matches(CtNewClass<?> element) { return getSimpleName().equals(element.getAnonymousClass().getSimpleName()); } }).get(0); return elements.getAnonymousClass(); } return null; }