diff options
Diffstat (limited to 'javaparser-testing/src/test/resources/com/github/javaparser/bdd/parsing_scenarios.story')
| -rw-r--r-- | javaparser-testing/src/test/resources/com/github/javaparser/bdd/parsing_scenarios.story | 500 |
1 files changed, 500 insertions, 0 deletions
diff --git a/javaparser-testing/src/test/resources/com/github/javaparser/bdd/parsing_scenarios.story b/javaparser-testing/src/test/resources/com/github/javaparser/bdd/parsing_scenarios.story new file mode 100644 index 000000000..9f6ee243d --- /dev/null +++ b/javaparser-testing/src/test/resources/com/github/javaparser/bdd/parsing_scenarios.story @@ -0,0 +1,500 @@ +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 |