| Scenario: Test declaration as String for constructor on parsed class |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class ClassWithAConstructor { |
| protected ClassWithAConstructor(int a, String b) throws This, AndThat, AndWhatElse { |
| } |
| } |
| Then constructor 1 in class 1 declaration as a String is "protected ClassWithAConstructor(int a, String b) throws This, AndThat, AndWhatElse" |
| Then all nodes refer to their parent |
| |
| |
| Scenario: Test declaration as String exclusing modifiers and throws for constructor on parsed class |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class ClassWithAConstructor { |
| protected ClassWithAConstructor(int a, String b) throws This, AndThat, AndWhatElse { |
| } |
| } |
| Then constructor 1 in class 1 declaration short form as a String is "ClassWithAConstructor(int a, String b)" |
| Then all nodes refer to their parent |
| |
| |
| Scenario: Test declaration as String exclusing modifiers and throws for method on parsed class |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class ClassWithAMethod { |
| /*comment1*/ |
| final protected /*comment2*/ native List<String> /*comment2*/ aMethod(int a, String b) throws /*comment3*/ This, AndThat, AndWhatElse { |
| |
| } |
| } |
| Then method 1 in class 1 declaration as a String is "protected final native List<String> aMethod(int a, String b) throws This, AndThat, AndWhatElse" |
| Then all nodes refer to their parent |
| |
| |
| Scenario: Test declaration as String exclusing modifiers and throws for method on parsed class |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class ClassWithAMethod { |
| /*comment1*/ |
| final protected /*comment2*/ native List<String> /*comment2*/ aMethod(int a, String b) throws /*comment3*/ This, AndThat, AndWhatElse { |
| |
| } |
| } |
| Then method 1 in class 1 declaration as a String short form is "List<String> aMethod(int a, String b)" |
| Then all nodes refer to their parent |
| |
| |
| Scenario: The same class source is parsed by two different compilation units and should therefore be equal |
| |
| Given a CompilationUnit |
| Given a second CompilationUnit |
| When the following source is parsed: |
| package japa.parser.comments; |
| public class ClassEquality { |
| |
| public void aMethod(){ |
| // first comment |
| int a=0; // second comment |
| } |
| } |
| When the following sources is parsed by the second CompilationUnit: |
| package japa.parser.comments; |
| public class ClassEquality { |
| |
| public void aMethod(){ |
| // first comment |
| int a=0; // second comment |
| } |
| } |
| Then the CompilationUnit is equal to the second CompilationUnit |
| Then the CompilationUnit has the same hashcode to the second CompilationUnit |
| Then all nodes refer to their parent |
| Then all nodes of the second compilation unit refer to their parent |
| |
| |
| Scenario: Two different class sources are parsed by two different compilation units and should not be equal |
| |
| Given a CompilationUnit |
| Given a second CompilationUnit |
| When the following source is parsed: |
| package japa.parser.comments; |
| public class ClassEquality { |
| |
| public void aMethod(){ |
| // first comment |
| int a=0; // second comment |
| } |
| } |
| When the following sources is parsed by the second CompilationUnit: |
| package japa.parser.comments; |
| public class DifferentClass { |
| |
| public void aMethod(){ |
| // first comment |
| int a=0; // second comment |
| } |
| } |
| Then the CompilationUnit is not equal to the second CompilationUnit |
| Then the CompilationUnit has a different hashcode to the second CompilationUnit |
| Then all nodes refer to their parent |
| Then all nodes of the second compilation unit refer to their parent |
| |
| |
| Scenario: Classes that only differ by comments should not be equal or have the same hashcode |
| |
| Given a CompilationUnit |
| Given a second CompilationUnit |
| When the following source is parsed: |
| package japa.parser.comments; |
| public class ClassEquality { |
| |
| public void aMethod(){ |
| // first comment |
| int a=0; // second comment |
| } |
| } |
| When the following sources is parsed by the second CompilationUnit: |
| package japa.parser.comments; |
| public class ClassEquality { |
| |
| public void aMethod(){ |
| // first comment |
| int a=0; |
| } |
| } |
| Then the CompilationUnit is not equal to the second CompilationUnit |
| Then the CompilationUnit has a different hashcode to the second CompilationUnit |
| Then all nodes refer to their parent |
| Then all nodes of the second compilation unit refer to their parent |
| |
| |
| Scenario: A class with a colon in the annoation value is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| package japa.parser.ast; |
| import org.junit.Test; |
| public class Issue37 { |
| public static @interface SomeAnnotation { |
| String value(); |
| } |
| // Parser bug: the type of this field |
| @SomeAnnotation("http://someURL.org/") |
| protected Test test; |
| } |
| Then field 1 in class 1 contains annotation 1 value is ""http://someURL.org/"" |
| Then all nodes refer to their parent |
| |
| |
| Scenario: A class with a Lambda is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| package bdd.samples; |
| import java.util.stream.Stream; |
| public class Lambdas { |
| |
| public static void main(String[] args) { |
| // Lambda Runnable |
| Runnable r1 = () -> System.out.println("Hello world!"); |
| Runnable r2 = () -> {}; |
| Runnable r3 = () -> { System.out.println("Hello world two!"); }; |
| |
| Stream<CharSequence> stream = Stream.generate((Supplier<CharSequence>) () -> "foo"); |
| } |
| } |
| Then lambda in statement 1 in method 1 in class 1 is called r1 |
| Then lambda in statement 2 in method 1 in class 1 is called r2 |
| Then lambda in statement 3 in method 1 in class 1 is called r3 |
| Then lambda in statement 1 in method 1 in class 1 body is "System.out.println("Hello world!");" |
| Then lambda in statement 2 in method 1 in class 1 block statement is null |
| Then lambda in statement 3 in method 1 in class 1 block statement is "System.out.println("Hello world two!");" |
| Then lambda in statement 1 in method 1 in class 1 is parent of contained body |
| Then lambda in statement 3 in method 1 in class 1 is parent of contained body |
| Then all nodes refer to their parent |
| Then lambda in method call in statement 4 in method 1 in class 1 body is ""foo";" |
| |
| |
| Scenario: A class with parameterized Lambdas is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| package com.github.javapasrser.bdd.parsing; |
| import java.util.function.Function; |
| public class ParameterizedLambdas { |
| public static void main(String[] args) { |
| Function<Integer,String> f1 = (Integer i) -> String.valueOf(i); |
| Function<Integer,String> f2 = (i) -> String.valueOf(i); |
| Function<Integer,String> f3 = i -> String.valueOf(i); |
| } |
| } |
| Then lambda in statement 1 in method 1 in class 1 is parent of contained parameter |
| Then lambda in statement 2 in method 1 in class 1 is parent of contained parameter |
| Then lambda in statement 3 in method 1 in class 1 is parent of contained parameter |
| Then lambda in statement 1 in method 1 in class 1 is parent of contained body |
| Then lambda in statement 2 in method 1 in class 1 is parent of contained body |
| Then lambda in statement 3 in method 1 in class 1 is parent of contained body |
| Then lambda in statement 1 in method 1 in class 1 has parameters with non-null type |
| Then lambda in statement 2 in method 1 in class 1 has parameters with non-null type |
| Then lambda in statement 3 in method 1 in class 1 has parameters with non-null type |
| |
| |
| Scenario: A class with multi-parameters Lambdas is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| package com.github.javapasrser.bdd.parsing; |
| import java.util.function.Function; |
| public class MultiParameterizedLambdas { |
| public static void main(String[] args) { |
| BiFunction<Integer, Integer, String> f = (a, b) -> String.valueOf(a) + String.valueOf(b); |
| } |
| } |
| Then lambda in statement 1 in method 1 in class 1 has parameters with non-null type |
| |
| |
| Scenario: A class with a method reference is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| public class Person { |
| |
| String name; |
| LocalDate birthday; |
| |
| public void sortByAge(Person[] people){ |
| Arrays.sort(people, Person::compareByAge); |
| } |
| |
| public static int compareByAge(Person a, Person b) { |
| return a.birthday.compareTo(b.birthday); |
| } |
| } |
| Then method reference in statement 1 in method 1 in class 1 scope is Person |
| Then method reference in statement 1 in method 1 in class 1 identifier is compareByAge |
| Then all nodes refer to their parent |
| |
| |
| Scenario: An interface with a default method is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| interface MyInterface { |
| default String doSomething(){ |
| return "implementation in an interface!"; |
| } |
| |
| String doSomethingElse(); |
| } |
| Then method 1 class 1 is a default method |
| Then method 2 class 1 is not a default method |
| Then all nodes refer to their parent |
| |
| Scenario: A lambda expression inside a conditional expression is parsed by the Java Parser |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| public class A{ |
| static <T> Predicate<T> isEqual(Object targetRef) { |
| return (null == targetRef)? Objects::isNull : object -> targetRef.equals(object); |
| } |
| } |
| Then ThenExpr in the conditional expression of the statement 1 in method 1 in class 1 is LambdaExpr |
| |
| Scenario: Parsing array creation expressions the positions are correct |
| |
| Given a CompilationUnit |
| When the following source is parsed (trimming space): |
| public class A{ |
| int[][] a = new int[][]{}; |
| } |
| When I take the ArrayCreationExpr |
| Then the begin line is 2 |
| Then the begin column is 17 |
| Then the end line is 2 |
| Then the end column is 29 |
| |
| Scenario: simple cast on lambda expression can be parsed |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| static final Comparator<ChronoLocalDate> DATE_ORDER = |
| (Comparator<ChronoLocalDate>) (date1, date2) -> { |
| return Long.compare(date1.toEpochDay(), date2.toEpochDay()); |
| }; |
| } |
| Then all nodes refer to their parent |
| |
| |
| Scenario: a combined cast on lambda expression can be parsed |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| static final Comparator<ChronoLocalDate> DATE_ORDER = |
| (Comparator<ChronoLocalDate> & Serializable) (date1, date2) -> { |
| return Long.compare(date1.toEpochDay(), date2.toEpochDay()); |
| }; |
| } |
| Then all nodes refer to their parent |
| |
| |
| Scenario: a combined cast on a literal can be parsed |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| static int a = (Comparator<ChronoLocalDate> & Serializable) 1; |
| } |
| Then all nodes refer to their parent |
| |
| |
| Scenario: Parsing excess semicolons on CompilationUnit level should work |
| Given a CompilationUnit |
| When the following source is parsed: |
| ; |
| package a; |
| ; |
| import foo.a; |
| ; |
| class A { } |
| ; |
| Then no errors are reported |
| |
| Scenario: Parsing excess semicolons in an AnnotationTypeDeclaration should work |
| Given a CompilationUnit |
| When the following source is parsed: |
| @interface A { |
| ; |
| ; |
| } |
| Then no errors are reported |
| |
| Scenario: Classes that are thrown from a method can be annotated |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| void a() throws @Abc X { |
| } |
| } |
| Then no errors are reported |
| |
| Scenario: Classes that are thrown from a constructor can be annotated |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| A() throws @Abc X { |
| } |
| } |
| Then no errors are reported |
| |
| |
| Scenario: Parsing trailing semicolons inside the imports area should work |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| import foo.a;; |
| import foo.b; |
| |
| class A { |
| } |
| Then no errors are reported |
| |
| |
| Scenario: Full package name should be parsed |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| package com.github.javaparser.bdd; |
| class C {} |
| When I take the PackageDeclaration |
| Then the package name is com.github.javaparser.bdd |
| |
| |
| Scenario: Strings with unescaped newlines are illegal (issue 211) |
| Given the class: |
| class A { |
| public void helloWorld(String greeting, String name) { |
| return "hello |
| world"; |
| } |
| } |
| Then the Java parser cannot parse it because of an error |
| |
| Scenario: Chars with unescaped newlines are illegal (issue 211) |
| Given the class: |
| class A { |
| public void helloWorld(String greeting, String name) { |
| return ' |
| '; |
| } |
| } |
| Then the Java parser cannot parse it because of an error |
| |
| Scenario: Diamond Operator information is exposed |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| List<String> args = new ArrayList<>(); |
| } |
| When I take the ObjectCreationExpr |
| Then the type's diamond operator flag should be true |
| |
| Scenario: Diamond Operator can be parsed also with space and comments |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| List<String> args = new ArrayList< /*hello*/ >(); |
| } |
| When I take the ObjectCreationExpr |
| Then the type's diamond operator flag should be true |
| |
| Scenario: Type Arguments are not specified |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| List args = new ArrayList(); |
| } |
| When I take the ObjectCreationExpr |
| Then the type's diamond operator flag should be false |
| |
| Scenario: Type Arguments are specified |
| |
| Given a CompilationUnit |
| When the following source is parsed: |
| class A { |
| Either<Ok, Error> either = new Either<Ok, Error>(); |
| } |
| When I take the ObjectCreationExpr |
| Then the type's diamond operator flag should be false |
| |
| Scenario: A method reference with type arguments is parsed correctly |
| Given a CompilationUnit |
| When the following source is parsed: |
| class X { |
| void x() { |
| a.orElseGet( Stream::<IVariable<?>>empty ); |
| } |
| } |
| Then no errors are reported |
| |
| Scenario: The target of this assignExpr is not null |
| Given a CompilationUnit |
| When the following source is parsed: |
| public class Example { |
| private String mString; |
| public Example(String arg) { |
| mString = arg; |
| } |
| } |
| Then the assignExpr produced doesn't have a null target |
| |
| Scenario: Two comments in one line, and a unicode space |
| Given a CompilationUnit |
| When the following source is parsed: |
| public class Example { |
| Object mAvailablePrimaryConnection; |
| public Example(String arg) { |
| ​mAvailablePrimaryConnection = openConnectionLocked(mConfiguration, |
| true /*primaryConnection*/); // comment |
| } |
| } |
| Then no errors are reported |
| |
| Scenario: alternative [] placings |
| Given a CompilationUnit |
| When the following source is parsed: |
| class I{int[]bar(int[]x[])[]{return new int[][]{};}} |
| Then no errors are reported |
| |
| Scenario: try requires resources, a finally or a catch (issue 442) |
| Given the class: |
| class A { |
| public void helloWorld() { |
| try { |
| } |
| } |
| } |
| Then the Java parser cannot parse it because of an error |
| |
| |
| Scenario: Partially dimensioned arrays are fine |
| Given a CompilationUnit |
| When the following source is parsed: |
| class X { |
| int a = new int @A [10] @A [20] @A [] []; |
| int b = new int @A [] @A []{{1}}; |
| } |
| Then no errors are reported |