diff options
Diffstat (limited to 'test/scaladoc')
34 files changed, 689 insertions, 1244 deletions
diff --git a/test/scaladoc/javascript/test-index.html b/test/scaladoc/javascript/test-index.html index 42cbc8cc09..91756b5be1 100644 --- a/test/scaladoc/javascript/test-index.html +++ b/test/scaladoc/javascript/test-index.html @@ -6,7 +6,6 @@ src="http://code.jquery.com/qunit/git/qunit.js"></script> <script type="text/javascript" src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/jquery.js"></script> - <script src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/jquery.layout.js"></script> <script src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/scheduler.js"></script> <script type="text/javascript" src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/index.js"></script> diff --git a/test/scaladoc/resources/SI-10027.java b/test/scaladoc/resources/SI-10027.java new file mode 100644 index 0000000000..28d212ffed --- /dev/null +++ b/test/scaladoc/resources/SI-10027.java @@ -0,0 +1,5 @@ +/** + * Around 20k characters + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + */ +public class JavaComments {} diff --git a/test/scaladoc/resources/SI-4826.java b/test/scaladoc/resources/SI-4826.java new file mode 100644 index 0000000000..18a1cb86f2 --- /dev/null +++ b/test/scaladoc/resources/SI-4826.java @@ -0,0 +1,309 @@ +/** + * A package header + */ +package test.scaladoc; + +/** + * Testing java comments. The presence of a :marker: + * tag is verified by tests. + */ +public class JavaComments { + + /** A field */ + public final int x; + /** A field */ + protected int y; + /** A field */ + private int z; + + /** + * Inner class + */ + public class Inner { + /** Inner method */ + public void foo() { + } + } + + /** + * A typed inner class + * @param <T> some type + */ + public class InnerTyped<T> { + } + + /** + * Compute the answer to the ultimate question of life, the + * universe, and everything. :marker: + * @param factor scaling factor to the answer + * @return the answer to everything (42) scaled by factor + */ + public int answer(int factor) { + return 42 * factor; + } + + /** Private */ + private double foo(double value) { + return value; + } + + /** Protected */ + protected double bar(double value) { + return value; + } + + /** No qualifier*/ + String noqualifier() { + return "something"; + } + + /** Void */ + public void voidmethod(boolean t) { + } + + /** + * Typed parameter + * @param <A> the parameter type + * @param a parameter + * @return something + */ + public <A> void tparams(A a) { + } + + /** + * Typed parameter + * @param <A> the return type + * @param <B> the parameter typeA + * @param b parameter + * @return casts B to A + */ + public <A, B extends A> A cast(B b) { + return (B) b; + } + +} + +// The following snippet is taken from Akka, it mainly tests interfaces + +/** + * Class that encapsulates all the Functional Interfaces + * used for creating partial functions. + * + * This is an EXPERIMENTAL feature and is subject to change until it has received more real world testing. + */ +public final class FI { + + /** Doc comment on constructor */ + private FI() { + } + + /** + * Functional interface for an application. + * + * @param <I> the input type, that this Apply will be applied to + * @param <R> the return type, that the results of the application will have + */ + public static interface Apply<I, R> { + /** + * The application to perform. + * + * @param i an instance that the application is performed on + * @return the result of the application + */ + public R apply(I i) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param <I1> the first input type, that this Apply will be applied to + * @param <I2> the second input type, that this Apply will be applied to + * @param <R> the return type, that the results of the application will have + */ + public static interface Apply2<I1, I2, R> { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @return the result of the application + */ + public R apply(I1 i1, I2 i2) throws Exception; + } + + /** + * Functional interface for a predicate. + * + * @param <T> the type that the predicate will operate on. + */ + public static interface TypedPredicate<T> { + /** + * The predicate to evaluate. + * + * @param t an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(T t); + } + + /** + * Functional interface for a predicate. + * + * @param <T> the type that the predicate will operate on. + * @param <U> the type that the predicate will operate on. + */ + public static interface TypedPredicate2<T, U> { + /** + * The predicate to evaluate. + * + * @param t an instance that the predicate is evaluated on. + * @param u an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(T t, U u); + } + + /** + * Functional interface for an application. + * + * @param <I> the input type, that this Apply will be applied to + */ + public static interface UnitApply<I> { + /** + * The application to perform. + * + * @param i an instance that the application is performed on + */ + public void apply(I i) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param <I1> the first input type, that this Apply will be applied to + * @param <I2> the second input type, that this Apply will be applied to + */ + public static interface UnitApply2<I1, I2> { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param <I1> the first input type, that this Apply will be applied to + * @param <I2> the second input type, that this Apply will be applied to + * @param <I3> the third input type, that this Apply will be applied to + */ + public static interface UnitApply3<I1, I2, I3> { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @param i3 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2, I3 i3) throws Exception; + } + + /** + * Functional interface for an application. + * + * @param <I1> the first input type, that this Apply will be applied to + * @param <I2> the second input type, that this Apply will be applied to + * @param <I3> the third input type, that this Apply will be applied to + * @param <I4> the fourth input type, that this Apply will be applied to + */ + public static interface UnitApply4<I1, I2, I3, I4> { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @param i3 an instance that the application is performed on + * @param i4 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2, I3 i3, I4 i4) throws Exception; + } + + /** + * Functional interface for an application. + */ + public static interface UnitApplyVoid { + /** + * The application to perform. + */ + public void apply() throws Exception; + } + + /** + * Package scoped functional interface for a predicate. Used internally to match against arbitrary types. + */ + static interface Predicate { + /** + * The predicate to evaluate. + * + * @param o an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(Object o); + } + + /** comment about */ + /** a comment about */ + /** a comment */ + void foo() {} + + /** someone forgot to uncomment */ + //void thisMethod() {} + /** and also this */ + //void otherMethod() {} +} + +/** + * Functional interface for an application. + * + * @param <I1> the first input type, that this Apply will be applied to + * @param <I2> the second input type, that this Apply will be applied to + * @param <I3> the third input type, that this Apply will be applied to + * @param <I4> the fourth input type, that this Apply will be applied to + */ +public interface UnitApply4<I1, I2, I3, I4> { + /** + * The application to perform. + * + * @param i1 an instance that the application is performed on + * @param i2 an instance that the application is performed on + * @param i3 an instance that the application is performed on + * @param i4 an instance that the application is performed on + */ + public void apply(I1 i1, I2 i2, I3 i3, I4 i4) throws Exception; +} + +/** + * Functional interface for an application. + */ +public interface UnitApplyVoid { + /** + * The application to perform. + */ + public void apply() throws Exception; +} + +/** + * Package scoped functional interface for a predicate. Used internally to match against arbitrary types. + */ +interface Predicate { + /** + * The predicate to evaluate. + * + * @param o an instance that the predicate is evaluated on. + * @return the result of the predicate + */ + public boolean defined(Object o); +} diff --git a/test/scaladoc/resources/SI-9599.scala b/test/scaladoc/resources/SI-9599.scala new file mode 100644 index 0000000000..9365243ffb --- /dev/null +++ b/test/scaladoc/resources/SI-9599.scala @@ -0,0 +1,6 @@ +/** + * @todo todo1 + * @todo todo2 + * @todo todo3 + */ +class X diff --git a/test/scaladoc/resources/links.scala b/test/scaladoc/resources/links.scala index 8e000ab979..b6a6b08209 100644 --- a/test/scaladoc/resources/links.scala +++ b/test/scaladoc/resources/links.scala @@ -38,7 +38,7 @@ package scala.test.scaladoc.links { /** * Links to the trait: - * - [[scala.test.scaladoc.links.Target$ object Test]] + * - [[scala.test.scaladoc.links.Target$ object Target]] * - [[scala.test package scala.test]] * - [[scala.test.scaladoc.links.Target!.T trait Target -> type T]] * - [[test.scaladoc.links.Target!.S trait Target -> type S]] @@ -51,7 +51,7 @@ package scala.test.scaladoc.links { * - [[Target$.foo(z:Str* object Target -> def foo]] * - [[Target$.bar object Target -> def bar]] * - [[[[Target$.foo[A[_[_]]]* trait Target -> def foo with 3 nested tparams]]]] (should exercise nested parens) - * - [[Target.onlyInObject object Target -> def foo]] (should find the object) + * - [[Target.onlyInObject object Target -> onlyInObject]] * - [[Target$.C object Target -> class C]] (should link directly to C, not as a member) * - [[Target!.C trait Target -> class C]] (should link directly to C, not as a member) * - [[Target$.baz(c:scala\.test\.scaladoc\.links\.C)* object Target -> def baz]] (should use dots in prefix) diff --git a/test/scaladoc/run/SI-6017.check b/test/scaladoc/run/SI-10027.check index 619c56180b..619c56180b 100644 --- a/test/scaladoc/run/SI-6017.check +++ b/test/scaladoc/run/SI-10027.check diff --git a/test/scaladoc/run/SI-10027.scala b/test/scaladoc/run/SI-10027.scala new file mode 100644 index 0000000000..d720d8371c --- /dev/null +++ b/test/scaladoc/run/SI-10027.scala @@ -0,0 +1,12 @@ +import scala.tools.nsc.doc.Universe +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocJavaModelTest + +object Test extends ScaladocJavaModelTest { + + override def resourceFile = "SI-10027.java" + override def scaladocSettings = "" + + // just make sure it compiles + def testModel(rootPackage: Package) = {} +} diff --git a/test/scaladoc/run/SI-4826-no-comments.check b/test/scaladoc/run/SI-4826-no-comments.check new file mode 100644 index 0000000000..3925a0d464 --- /dev/null +++ b/test/scaladoc/run/SI-4826-no-comments.check @@ -0,0 +1 @@ +Done.
\ No newline at end of file diff --git a/test/scaladoc/run/SI-4826-no-comments.scala b/test/scaladoc/run/SI-4826-no-comments.scala new file mode 100644 index 0000000000..217fc29d81 --- /dev/null +++ b/test/scaladoc/run/SI-4826-no-comments.scala @@ -0,0 +1,20 @@ +import scala.tools.nsc.doc.Universe +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocJavaModelTest + +object Test extends ScaladocJavaModelTest { + + override def resourceFile = "SI-4826.java" + override def scaladocSettings = "-no-java-comments" + + def testModel(rootPackage: Package) = { + import access._ + + val base = rootPackage._package("test")._package("scaladoc") + val clazz = base._class("JavaComments") + val method = clazz._method("answer") + + assert(clazz.comment == None) + assert(method.comment == None) + } +} diff --git a/test/scaladoc/run/SI-4826.check b/test/scaladoc/run/SI-4826.check new file mode 100644 index 0000000000..619c56180b --- /dev/null +++ b/test/scaladoc/run/SI-4826.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/SI-4826.scala b/test/scaladoc/run/SI-4826.scala new file mode 100644 index 0000000000..6d4b3a6da7 --- /dev/null +++ b/test/scaladoc/run/SI-4826.scala @@ -0,0 +1,21 @@ +import scala.tools.nsc.doc.Universe +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocJavaModelTest + +object Test extends ScaladocJavaModelTest { + + override def resourceFile = "SI-4826.java" + override def scaladocSettings = "" + + def testModel(rootPackage: Package) = { + import access._ + val Tag = ":marker:" + + val base = rootPackage._package("test")._package("scaladoc") + val clazz = base._class("JavaComments") + val method = clazz._method("answer") + + assert(extractCommentText(clazz.comment.get).contains(Tag)) + assert(extractCommentText(method.comment.get).contains(Tag)) + } +} diff --git a/test/scaladoc/run/SI-6017.scala b/test/scaladoc/run/SI-6017.scala deleted file mode 100644 index 9951534c6d..0000000000 --- a/test/scaladoc/run/SI-6017.scala +++ /dev/null @@ -1,28 +0,0 @@ -import scala.tools.nsc.doc -import scala.tools.nsc.doc.model._ -import scala.tools.nsc.doc.html.page.{Index, ReferenceIndex} -import scala.tools.partest.ScaladocModelTest - -object Test extends ScaladocModelTest { - override def scaladocSettings = "" - override def code = """ - class STAR - class Star - """ - - def testModel(rootPackage: Package) { - model match { - case Some(universe) => { - val index = IndexModelFactory.makeIndex(universe) - // Because "STAR" and "Star" are different - assert(index.firstLetterIndex('s').keys.toSeq.length == 2) - - val indexPage = new Index(universe, index) - val letters = indexPage.letters - assert(letters.length > 1) - assert(letters(0).toString == "<span>#</span>") - } - case _ => assert(false) - } - } -} diff --git a/test/scaladoc/run/SI-6580.scala b/test/scaladoc/run/SI-6580.scala index c544138f44..55168a060b 100644 --- a/test/scaladoc/run/SI-6580.scala +++ b/test/scaladoc/run/SI-6580.scala @@ -1,6 +1,5 @@ import scala.tools.nsc.doc import scala.tools.nsc.doc.model._ -import scala.tools.nsc.doc.html.page.{Index, ReferenceIndex} import scala.tools.partest.ScaladocModelTest object Test extends ScaladocModelTest { diff --git a/test/scaladoc/run/SI-9620.check b/test/scaladoc/run/SI-9620.check new file mode 100644 index 0000000000..619c56180b --- /dev/null +++ b/test/scaladoc/run/SI-9620.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/SI-9620.scala b/test/scaladoc/run/SI-9620.scala new file mode 100644 index 0000000000..cac34d1c18 --- /dev/null +++ b/test/scaladoc/run/SI-9620.scala @@ -0,0 +1,42 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + package a + + trait Foo[S] { + def foo(t: S): Int = 123 + } + + /** Boo with only one foo method, hopefully! + * @hideImplicitConversion BooShouldNotAppearIsFoo + */ + trait Boo[T] + + object Boo { + sealed trait ShouldNotAppear + implicit class BooShouldNotAppearIsFoo(boo: Boo[ShouldNotAppear]) extends Foo[ShouldNotAppear] + implicit class BooLongIsFoo(boo: Boo[Long]) extends Foo[Long] + } + """ + + def scaladocSettings = "-implicits" + + def testModel(rootPackage: Package) = { + import access._ + + // Assert Boo only has one implicit conversion + val boo = rootPackage._package("a")._trait("Boo") + val conversions = boo._conversions("a.Boo.BooShouldNotAppearIsFoo") ++ boo._conversions("a.Boo.BooLongIsFoo") + assert(conversions.length == 1, conversions.length + " == 1") + + // Assert that the implicit conversion is not "BooShouldNotAppearIsFoo" + assert(conversions.head.conversionShortName == "BooLongIsFoo", + conversions.head.conversionShortName + " == BooLongIsFoo") + + // Assert that the same for full path + assert(conversions.head.conversionQualifiedName == "a.Boo.BooLongIsFoo", + conversions.head.conversionQualifiedName + " == a.Boo.BooLongIsFoo") + } +} diff --git a/test/scaladoc/run/SI-9704.check b/test/scaladoc/run/SI-9704.check new file mode 100644 index 0000000000..5a73befd9b --- /dev/null +++ b/test/scaladoc/run/SI-9704.check @@ -0,0 +1,4 @@ +Chain(List(Chain(List(Text(Demonstrates a scala issue in which the closing link tag is duplicated), Text( +), HtmlTag(<a href="https://link">title</a>), Text( +), Text())))) +Done. diff --git a/test/scaladoc/run/SI-9704.scala b/test/scaladoc/run/SI-9704.scala new file mode 100644 index 0000000000..e6f071704e --- /dev/null +++ b/test/scaladoc/run/SI-9704.scala @@ -0,0 +1,22 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + object Foo { + /** + * Demonstrates a scala issue in which the closing link tag is duplicated + * <a href="https://link">title</a> + */ + def bar = ??? + } + """ + + def scaladocSettings = "" + + def testModel(root: Package) = { + import access._ + val thing = root._object("Foo")._method("bar") + println(thing.comment.get.short) + } +} diff --git a/test/scaladoc/run/inlineToStr-strips-unwanted-text.check b/test/scaladoc/run/inlineToStr-strips-unwanted-text.check new file mode 100644 index 0000000000..619c56180b --- /dev/null +++ b/test/scaladoc/run/inlineToStr-strips-unwanted-text.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/inlineToStr-strips-unwanted-text.scala b/test/scaladoc/run/inlineToStr-strips-unwanted-text.scala new file mode 100644 index 0000000000..8faaf1b93d --- /dev/null +++ b/test/scaladoc/run/inlineToStr-strips-unwanted-text.scala @@ -0,0 +1,58 @@ +import scala.tools.nsc.doc.html.Page +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + + override def code = """ + /** This comment contains ^superscript^ */ + class Foo { + /** This comment contains ,,subscript,, */ + def bar = ??? + + /** This comment contains a link [[https://scala.epfl.ch/]] */ + def baz = ??? + + /** This comment contains an <strong>html tag</strong> */ + def qux = ??? + + /** This comment contains a<br> single html tag */ + def quux = ??? + + /** This comment contains nested <strong>html<br> tags</strong> */ + def quuz = ??? + + /** This comment contains a [[corge ,,link with a subscript title,,]] */ + def corge = ??? + } + """ + def scaladocSettings = "" + + def testModel(root: Package) = { + import scala.tools.nsc.doc.base.comment._ + import access._ + + val foo = root._class("Foo") + + val fooStr = Page.inlineToStr(foo.comment.get.short) + assert(fooStr == "This comment contains superscript", fooStr) + + val barStr = Page.inlineToStr(foo._method("bar").comment.get.short) + assert(barStr == "This comment contains subscript", barStr) + + val bazStr = Page.inlineToStr(foo._method("baz").comment.get.short) + assert(bazStr == "This comment contains a link https://scala.epfl.ch/", bazStr) + + val quxStr = Page.inlineToStr(foo._method("qux").comment.get.short) + assert(quxStr == "This comment contains an html tag", quxStr) + + val quuxStr = Page.inlineToStr(foo._method("quux").comment.get.short) + assert(quuxStr == "This comment contains a single html tag", quuxStr) + + val quuzStr = Page.inlineToStr(foo._method("quuz").comment.get.short) + assert(quuzStr == "This comment contains nested html tags", quuzStr) + + val corgeStr = Page.inlineToStr(foo._method("corge").comment.get.short) + assert(corgeStr == "This comment contains a link with a subscript title", corgeStr) + } +} diff --git a/test/scaladoc/run/shortDescription-annotation.check b/test/scaladoc/run/shortDescription-annotation.check new file mode 100644 index 0000000000..619c56180b --- /dev/null +++ b/test/scaladoc/run/shortDescription-annotation.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/shortDescription-annotation.scala b/test/scaladoc/run/shortDescription-annotation.scala new file mode 100644 index 0000000000..4f9a891133 --- /dev/null +++ b/test/scaladoc/run/shortDescription-annotation.scala @@ -0,0 +1,44 @@ +import scala.tools.nsc.doc.html.Page +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + package a + + /** This comment should not appear + * @shortDescription This one should appear + */ + class Foo { + /** This comment should appear */ + def foo: Int = 1 + + /** This comment should not appear + * @shortDescription This comment should appear + */ + def goo: Int = 2 + } + """ + + // no need for special settings + def scaladocSettings = "" + + def testModel(rootPackage: Package) = { + import scala.tools.nsc.doc.base.comment._ + import access._ + + val foo = rootPackage._package("a")._class("Foo") + + // Assert that the class has the correct short description + val classDesc = Page.inlineToStr(foo.comment.get.short) + assert(classDesc == "This one should appear", classDesc) + + // Assert that the `foo` method has the correct short description + val fooDesc = Page.inlineToStr(foo._method("foo").comment.get.short) + assert(fooDesc == "This comment should appear", fooDesc) + + // Assert that the `goo` method has the correct short description + val gooDesc = Page.inlineToStr(foo._method("goo").comment.get.short) + assert(gooDesc == "This comment should appear", gooDesc) + } +} diff --git a/test/scaladoc/run/t7767.scala b/test/scaladoc/run/t7767.scala index 6c9ceb511d..433fc5c0c4 100644 --- a/test/scaladoc/run/t7767.scala +++ b/test/scaladoc/run/t7767.scala @@ -4,15 +4,49 @@ import scala.tools.partest.ScaladocModelTest object Test extends ScaladocModelTest { override def code = """ - class Docable extends { /**Doc*/ val foo = 0 } with AnyRef - """ + class CEarly extends { /**CEarly_Doc_foo*/ val foo = 0 } with AnyRef + trait TEarly extends { /**TEarly_Doc_foo*/ val foo = 0 } with AnyRef + class C { + /**C_Doc_sigInferred*/ val sigInferred = 0 + /**C_Doc_const*/ final val const = 0 + /**C_Doc_varr*/ var varr: Any = null + /**C_Doc_abs*/ val abs: Int + /**C_Doc_absVar*/ var absVar: Any + /**C_Doc_lazyValInferred*/ lazy val lazyValInferred = 0 + /**C_Doc_lazyValConst*/ final lazy val lazyValConst = 0 + /**C_Doc_lazyValUnit*/ lazy val lazyValUnit: Unit = println() + /**C_Doc_lazyVal*/ lazy val lazyVal: Int = 0 + } + trait T { + /**T_Doc_sigInferred*/ val sigInferred = 0 + /**T_Doc_const*/ final val const = 0 + /**T_Doc_varr*/ var varr: Any = null + /**T_Doc_abs*/ val abs: Int + /**T_Doc_absVar*/ var absVar: Any + /**T_Doc_lazyValInferred*/ lazy val lazyValInferred = 0 + /**T_Doc_lazyValConst*/ final lazy val lazyValConst = 0 + /**T_Doc_lazyValUnit*/ lazy val lazyValUnit: Unit = println() + /**T_Doc_lazyVal*/ lazy val lazyVal: Int = 0 + }""" // no need for special settings def scaladocSettings = "" + def assertDoc(classEntity: DocTemplateEntity, valName: String) = { + import access._ + val comment = classEntity._value(valName).comment.map(_.body.toString.trim).getOrElse("") + val className = classEntity.name + val marker = s"${className}_Doc_${valName}" + assert(comment.contains(marker), s"Expected $marker in comment for $valName in $className, found: $comment.") + } + def testModel(rootPackage: Package) = { import access._ - val comment = rootPackage._class("Docable")._value("foo").comment.map(_.body.toString.trim).getOrElse("") - assert(comment.contains("Doc"), comment) + assertDoc(rootPackage._class("CEarly"), "foo") + assertDoc(rootPackage._trait("TEarly"), "foo") + + val valNames = List("sigInferred", "const", "varr", "abs", "absVar", "lazyValInferred", "lazyValConst", "lazyValUnit", "lazyVal") + val entities = List(rootPackage._class("C"), rootPackage._trait("T")) + for (e <- entities; vn <- valNames) assertDoc(e, vn) } } diff --git a/test/scaladoc/run/t7905.check b/test/scaladoc/run/t7905.check new file mode 100644 index 0000000000..619c56180b --- /dev/null +++ b/test/scaladoc/run/t7905.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/t7905.scala b/test/scaladoc/run/t7905.scala new file mode 100644 index 0000000000..8570724470 --- /dev/null +++ b/test/scaladoc/run/t7905.scala @@ -0,0 +1,36 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + object A { + val foo = new B { + val bar = new C { + val baz: A.this.type = A.this + } + } + } + + trait B { + type E = bar.D + + val bar: C + } + + trait C { + trait D + } + + trait G { + type F = A.foo.E + + def m(f: F) = f match { + case _: A.foo.bar.D => // error here + } + } + """ + + def scaladocSettings = "" + + def testModel(root: Package) = () +} diff --git a/test/scaladoc/run/t9585.check b/test/scaladoc/run/t9585.check new file mode 100644 index 0000000000..3784317d54 --- /dev/null +++ b/test/scaladoc/run/t9585.check @@ -0,0 +1,6 @@ +warning: there was one feature warning; re-run with -feature for details +any2stringadd[Box[T]] +StringFormat[Box[T]] +Ensuring[Box[T]] +ArrowAssoc[Box[T]] +Done. diff --git a/test/scaladoc/run/t9585.scala b/test/scaladoc/run/t9585.scala new file mode 100644 index 0000000000..af8350b6cf --- /dev/null +++ b/test/scaladoc/run/t9585.scala @@ -0,0 +1,25 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + object Box { + + implicit def anyToBox[T](t: T): Box[T] = new Box(t) + + } + + class Box[T](val t: T) + """ + + def scaladocSettings = "-implicits" + + def testModel(root: Package) = { + import access._ + + // this used to contain the conversion to Box[Box[T]], + // but not anymore. + val conversions = root._class("Box").conversions + println(conversions.map(_.targetType).mkString("\n")) + } +} diff --git a/test/scaladoc/run/t9752.check b/test/scaladoc/run/t9752.check new file mode 100644 index 0000000000..daeafb8ecc --- /dev/null +++ b/test/scaladoc/run/t9752.check @@ -0,0 +1,5 @@ +List(Body(List(Paragraph(Chain(List(Summary(Text())))), Code(class A + + +class B)))) +Done. diff --git a/test/scaladoc/run/t9752.scala b/test/scaladoc/run/t9752.scala new file mode 100644 index 0000000000..b11c7f5c32 --- /dev/null +++ b/test/scaladoc/run/t9752.scala @@ -0,0 +1,28 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + + override def code = s""" + /** + * Foo + * + * @example + * {{{ + * class A + * + * + * class B + * }}} + */ + object Foo + """ + + def scaladocSettings = "" + + def testModel(root: Package) = { + import access._ + val obj = root._object("Foo") + println(obj.comment.get.example) + } +} diff --git a/test/scaladoc/scalacheck/CommentFactoryTest.scala b/test/scaladoc/scalacheck/CommentFactoryTest.scala deleted file mode 100644 index d30b78087c..0000000000 --- a/test/scaladoc/scalacheck/CommentFactoryTest.scala +++ /dev/null @@ -1,187 +0,0 @@ -import org.scalacheck._ -import org.scalacheck.Prop._ - -import scala.tools.nsc.Global -import scala.tools.nsc.doc -import scala.tools.nsc.doc.base.comment._ -import scala.tools.nsc.doc.model._ -import scala.tools.nsc.doc.model.diagram._ - -class Factory(val g: Global, val s: doc.Settings) - extends doc.model.ModelFactory(g, s) { - thisFactory: Factory - with ModelFactoryImplicitSupport - with ModelFactoryTypeSupport - with DiagramFactory - with CommentFactory - with doc.model.TreeFactory - with MemberLookup => - - def strip(c: Comment): Option[Inline] = { - c.body match { - case Body(List(Paragraph(Chain(List(Summary(inner)))))) => Some(inner) - case _ => None - } - } - - def getComment(s: String): Comment = - parse(s, "", scala.tools.nsc.util.NoPosition, null) - - def parseComment(s: String): Option[Inline] = - strip(getComment(s)) - - def createBody(s: String) = - parse(s, "", scala.tools.nsc.util.NoPosition, null).body -} - -object Test extends Properties("CommentFactory") { - val factory = { - val settings = new doc.Settings((str: String) => {}) - val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) - val g = new Global(settings, reporter) - (new Factory(g, settings) - with ModelFactoryImplicitSupport - with ModelFactoryTypeSupport - with DiagramFactory - with CommentFactory - with doc.model.TreeFactory - with MemberLookup) - } - - def parse(src: String, dst: Inline): Boolean = { - factory.parseComment(src) match { - case Some(inline) => - inline == dst - case _ => - false - } - } - - property("parse") = parse( - "/** One two three */", - Text("One two three") - ) - property("parse") = parse( - "/** One `two` three */", - Chain(List(Text("One "), Monospace(Text("two")), Text(" three"))) - ) - - property("parse") = parse( - """ -/** One two - * three */""", - Text("One two\nthree") - ) - property("parse") = parse( - """ -/** One `two` - * three */""", - Chain(List(Text("One "), Monospace(Text("two")), Text("\n"), Text("three"))) - ) - - property("parse") = parse( - """ -/** One `two` - * three */""", - Chain(List(Text("One "), Monospace(Text("two")), Text("\n"), Text(" three"))) - ) - - property("parse") = parse( - """ -/** One - * `two` three */""", - Chain(List(Text("One"), Text("\n"), Monospace(Text("two")), Text(" three"))) - ) - - property("Trac #4361 - ^...^") = parse( - """ -/** - * hello ^world^ */""", - Chain(List(Text("hello "), Superscript(Text("world")))) - ) - - property("Trac #4361 - single ^ symbol") = parse( - """ -/** - * <pre> - * hello ^world - * </pre> - * - */""", - Chain(List(Text(""), Text("\n"), - - - HtmlTag("<pre>\nhello ^world\n</pre>"))) - ) - - property("Trac #4366 - body") = { - val body = factory.createBody( - """ - /** - * <strong><code>foo</code> has been deprecated and will be removed in a future version. Please call <code>bar</code> instead.</strong> - */ - """ - ) - - body == Body(List(Paragraph(Chain(List( - Summary(Chain(List(HtmlTag("<strong><code>foo</code> has been deprecated and will be removed in a future version. Please call <code>bar</code> instead.</strong>"), Text("\n"), Text("")))) - ))))) - } - - property("Trac #4366 - summary") = { - val body = factory.createBody( - """ - /** - * <strong><code>foo</code> has been deprecated and will be removed in a future version. Please call <code>bar</code> instead.</strong> - */ - """ - ) - body.summary == Some(Chain(List(HtmlTag("<strong><code>foo</code> has been deprecated and will be removed in a future version. Please call <code>bar</code> instead.</strong>"), Text("\n"), Text("")))) - } - - property("Trac #4358 - body") = { - factory.createBody( - """ - /** - * Implicit conversion that invokes the <code>expect</code> method on the <code>EasyMock</code> companion object (<em>i.e.</em>, the - * static <code>expect</code> method in Java class <code>org.easymock.EasyMock</code>). - */ - """ - ) match { - case Body(List(Paragraph(Chain(List(Summary(Chain(List(Chain(List( - Text("Implicit conversion that invokes the "), - HtmlTag("<code>expect</code>"), - Text(" method on the "), - HtmlTag("<code>EasyMock</code>"), - Text(" companion object ("), - HtmlTag("<em>i.e.</em>"), - Text(", the\nstatic "), - HtmlTag("<code>expect</code>"), - Text(" method in Java class "), - HtmlTag("<code>org.easymock.EasyMock</code>"), - Text(")") - )), Text(".")))), Text("\n")))))) => - true - case other => { - println(other) - false - } - } - } - - property("Empty parameter text should be empty") = { - // used to fail with - // body == Body(List(Paragraph(Chain(List(Summary(Text('\n'))))))) - factory.getComment( - """ -/** - * @deprecated - */ - """).deprecated match { - case Some(Body(l)) if l.isEmpty => true - case other => - println(other) - false - } - } -} diff --git a/test/scaladoc/scalacheck/DeprecatedIndexTest.scala b/test/scaladoc/scalacheck/DeprecatedIndexTest.scala deleted file mode 100644 index 4a5a2001d4..0000000000 --- a/test/scaladoc/scalacheck/DeprecatedIndexTest.scala +++ /dev/null @@ -1,50 +0,0 @@ -import org.scalacheck._ -import org.scalacheck.Prop._ - -import scala.tools.nsc.doc -import scala.tools.nsc.doc.html.page.DeprecatedIndex -import java.net.{URLClassLoader, URLDecoder} - -object Test extends Properties("IndexScript") { - - def getClasspath = { - // these things can be tricky - // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths - // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. - // this test _will_ fail again some time in the future. - // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader - val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] - val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) - paths mkString java.io.File.pathSeparator - } - - val docFactory = { - val settings = new doc.Settings({Console.err.println(_)}) - settings.scaladocQuietRun = true - settings.nowarn.value = true - settings.classpath.value = getClasspath - val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) - new doc.DocFactory(reporter, settings) - } - - val indexModelFactory = doc.model.IndexModelFactory - - def createDeprecatedScript(path: String) = - docFactory.makeUniverse(Left(List(path))) match { - case Some(universe) => { - val index = new DeprecatedIndex(universe, indexModelFactory.makeIndex(universe)) - Some(index) - } - case _ => - None - } - - property("deprecated-list page lists deprecated members") = { - createDeprecatedScript("test/scaladoc/resources/SI-4476.scala") match { - case Some(p) => - p.deprecatedEntries.find(_._1 == "A").isDefined && - p.deprecatedEntries.find(_._1 == "bar").isDefined - case None => false - } - } -} diff --git a/test/scaladoc/scalacheck/HtmlFactoryTest.flags b/test/scaladoc/scalacheck/HtmlFactoryTest.flags deleted file mode 100644 index b2264ec4f4..0000000000 --- a/test/scaladoc/scalacheck/HtmlFactoryTest.flags +++ /dev/null @@ -1 +0,0 @@ --encoding UTF-8
\ No newline at end of file diff --git a/test/scaladoc/scalacheck/HtmlFactoryTest.scala b/test/scaladoc/scalacheck/HtmlFactoryTest.scala deleted file mode 100644 index 578e0382eb..0000000000 --- a/test/scaladoc/scalacheck/HtmlFactoryTest.scala +++ /dev/null @@ -1,817 +0,0 @@ -import org.scalacheck._ -import org.scalacheck.Prop._ - -import java.net.{URLClassLoader, URLDecoder} -import scala.collection.mutable -import scala.xml.NodeSeq - -object XMLUtil { - import scala.xml._ - - def stripGroup(seq: Node): Node = { - seq match { - case group: Group => { - <div class="group">{ group.nodes.map(stripGroup _) }</div> - } - case e: Elem => { - val child = e.child.map(stripGroup _) - Elem(e.prefix, e.label, e.attributes, e.scope, child : _*) - } - case _ => seq - } - } -} - -object Test extends Properties("HtmlFactory") { - - final val RESOURCES = "test/scaladoc/resources/" - - import scala.tools.nsc.doc.{DocFactory, Settings} - import scala.tools.nsc.doc.model.IndexModelFactory - import scala.tools.nsc.doc.html.HtmlFactory - import scala.tools.nsc.doc.html.page.ReferenceIndex - - def getClasspath = { - // these things can be tricky - // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths - // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. - // this test _will_ fail again some time in the future. - // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader - val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] - val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) - paths mkString java.io.File.pathSeparator - } - - def createFactory = { - val settings = new Settings({Console.err.println(_)}) - settings.scaladocQuietRun = true - settings.nowarn.value = true - settings.classpath.value = getClasspath - settings.docAuthor.value = true - - val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) - new DocFactory(reporter, settings) - } - - def createTemplates(basename: String): collection.Map[String, NodeSeq] = { - val result = mutable.Map[String, NodeSeq]() - - createFactory.makeUniverse(Left(List(RESOURCES+basename))) match { - case Some(universe) => { - val index = IndexModelFactory.makeIndex(universe) - (new HtmlFactory(universe, index)).writeTemplates((page) => { - result += (page.absoluteLinkTo(page.path) -> page.body) - }) - } - case _ => - } - - result - } - - def createReferenceIndex(basename: String) = { - createFactory.makeUniverse(Left(List(RESOURCES+basename))) match { - case Some(universe) => { - val index = IndexModelFactory.makeIndex(universe) - val pages = index.firstLetterIndex.map({ - case (key, value) => { - val page = new ReferenceIndex(key, index, universe) - page.absoluteLinkTo(page.path) -> page.body - } - }) - Some(pages) - } - case _ => - None - } - } - - def createTemplate(scala: String) = { - val html = scala.stripSuffix(".scala") + ".html" - createTemplates(scala)(html) - } - - /** - * This tests the text without the markup - ex: - * - * <h4 class="signature"> - * <span class="modifier_kind"> - * <span class="modifier">implicit</span> - * <span class="kind">def</span> - * </span> - * <span class="symbol"> - * <span class="name">test</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span> - * </span> - * </h4> - * - * becomes: - * - * implicit def test(): Int - * - * and is required to contain the text in the given checks - * - * NOTE: Comparison is done ignoring all whitespace - */ - def checkText(scalaFile: String, debug: Boolean = true)(checks: (Option[String], String, Boolean)*): Boolean = { - val htmlFile = scalaFile.stripSuffix(".scala") + ".html" - val htmlAllFiles = createTemplates(scalaFile) - var result = true - - for ((fileHint, check, expected) <- checks) { - // resolve the file to be checked - val fileName = fileHint match { - case Some(file) => - if (file endsWith ".html") - file - else - file + ".html" - case None => - htmlFile - } - val fileTextPretty = htmlAllFiles(fileName).text.replace('→',' ').replaceAll("\\s+"," ") - val fileText = fileTextPretty.replaceAll(" ", "") - - val checkTextPretty = check.replace('→',' ').replaceAll("\\s+"," ") - val checkText = checkTextPretty.replaceAll(" ", "") - - val checkValue = fileText.contains(checkText) == expected - if (debug && (!checkValue)) { - Console.err.println("") - Console.err.println("HTML Check failed for resource file " + scalaFile + ":") - Console.err.println("Could not match: \n" + checkTextPretty) - Console.err.println("In the extracted HTML text: \n" + fileTextPretty) - Console.err.println("NOTE: The whitespaces are eliminated before matching!") - Console.err.println("") - } - result &&= checkValue - } - - result - } - - def shortComments(root: scala.xml.Node) = - XMLUtil.stripGroup(root).descendant.flatMap { - case e: scala.xml.Elem => { - if (e.attribute("class").toString.contains("shortcomment")) { - Some(e) - } else { - None - } - } - case _ => None - } - - property("Trac #3790") = { - createTemplate("Trac3790.scala") match { - case node: scala.xml.Node => { - val comments = shortComments(node) - - comments.exists { _.toString.contains(">A lazy String\n</p>") } && - comments.exists { _.toString.contains(">A non-lazy String\n</p>") } - } - case _ => false - } - } - - property("Trac #4306") = { - val files = createTemplates("Trac4306.scala") - files("com/example/trac4306/foo/package$$Bar.html") != None - } - - property("Trac #4366") = { - createTemplate("Trac4366.scala") match { - case node: scala.xml.Node => { - shortComments(node).exists { n => { - val str = n.toString - str.contains("<code>foo</code>") && str.contains("</strong>") - } } - } - case _ => false - } - } - - property("Trac #4358") = { - createTemplate("Trac4358.scala") match { - case node: scala.xml.Node => - ! shortComments(node).exists { - _.toString.contains("<em>i.</em>") - } - case _ => false - } - } - - property("Trac #4180") = { - createTemplate("Trac4180.scala") != None - } - - property("Trac #4372") = { - createTemplate("Trac4372.scala") match { - case node: scala.xml.Node => { - val html = node.toString - html.contains("<span title=\"gt4s: $plus$colon\" class=\"name\">+:</span>") && - html.contains("<span title=\"gt4s: $minus$colon\" class=\"name\">-:</span>") && - html.contains("""<span class="params">(<span name="n">n: <span class="extype" name="scala.Int">Int</span></span>)</span><span class="result">: <span class="extype" name="scala.Int">Int</span></span>""") - } - case _ => false - } - } - - property("Trac #4374 - public") = { - val files = createTemplates("Trac4374.scala") - files("WithPublic.html") match { - case node: scala.xml.Node => { - val s = node.toString - s.contains("""href="WithPublic$.html"""") && - files.get("WithPublic$.html") != None - } - case _ => false - } - } - - property("Trac #4374 - private") = { - val files = createTemplates("Trac4374.scala") - files("WithPrivate.html") match { - case node: scala.xml.Node => { - val s = node.toString - ! s.contains("""href="WithPrivate$.html"""") && - files.get("WithPrivate$.html") == None - } - case _ => false - } - } - - property("Trac #4325 - files") = { - val files = createTemplates("Trac4325.scala") - - files.get("WithSynthetic.html") != None && - files.get("WithSynthetic$.html") == None && - files.get("WithObject.html") != None && - files.get("WithObject$.html") != None - } - - property("Trac #4325 - Don't link to syntetic companion") = { - val files = createTemplates("Trac4325.scala") - - files("WithSynthetic.html") match { - case node: scala.xml.Node => { - val s = node.toString - ! s.contains("""href="WithSynthetic$.html"""") - } - case _ => false - } - } - - property("Trac #4325 - Link to companion") = { - val files = createTemplates("Trac4325.scala") - - files("WithObject.html") match { - case node: scala.xml.Node => { - val s = node.toString - s.contains("""href="WithObject$.html"""") - } - case _ => false - } - } - - property("Trac #4420 - no whitespace at end of line") = { - val files = createTemplates("Trac4420.scala") - - files("TestA.html") match { - case node: scala.xml.Node => { - val s = node.toString - s.contains("""See YYY for more details""") - } - case _ => false - } - } - // - // property("Trac #484 - refinements and existentials") = { - // val files = createTemplates("Trac484.scala") - // val lines = """ - // |type Bar = AnyRef { type Dingus <: T forSome { type T <: String } } - // |type Foo = AnyRef { ... /* 3 definitions in type refinement */ } - // |def g(x: T forSome { type T <: String }): String - // |def h(x: Float): AnyRef { def quux(x: Int,y: Int): Int } - // |def hh(x: Float): AnyRef { def quux(x: Int,y: Int): Int } - // |def j(x: Int): Bar - // |def k(): AnyRef { type Dingus <: T forSome { type T <: String } } - // """.stripMargin.trim.lines map (_.trim) - // - // files("RefinementAndExistentials.html") match { - // case node: scala.xml.Node => { - // val s = node.text.replaceAll("\\s+", " ") - // lines forall (s contains _) - // } - // case _ => false - // } - // } - - property("Trac #4289") = { - val files = createTemplates("Trac4289.scala") - - files("Subclass.html") match { - case node: scala.xml.Node => { - node.toString.contains { - """<dt>returns</dt><dd class="cmt"><p>123</p></dd>""" - } - } - case _ => false - } - } - - property("Trac #4409") = { - createTemplate("Trac4409.scala") match { - case node: scala.xml.Node => { - ! node.toString.contains("""<div class="block"><ol>since""") - } - case _ => false - } - } - - property("Trac #4452") = { - createTemplate("Trac4452.scala") match { - case node: scala.xml.Node => - ! node.toString.contains(">*") - case _ => false - } - } - - property("Trac #4471") = { - createReferenceIndex("Trac4471.scala") match { - case Some(pages) => - (pages.get("index/index-f.html") match { - case Some(node) => node.toString.contains(">A</a></strike>") - case _ => false - }) && (pages.get("index/index-b.html") match { - case Some(node) => node.toString.contains(">bar</strike>") - case _ => false - }) - case _ => false - } - } - - property("SI-4641") = { - createReferenceIndex("SI_4641.scala") match { - case Some(pages) => pages.contains("index/index-_.html") - case _ => false - } - } - - property("SI-4421") = { - createTemplate("SI_4421.scala") match { - case node: scala.xml.Node => { - val html = node.toString - html.contains(">Example:") && html.contains(">Note<") - } - case _ => false - } - } - - property("SI-4589") = { - createTemplate("SI_4589.scala") match { - case node: scala.xml.Node => { - val html = node.toString - html.contains(">x0123456789: <") && - html.contains(">x012345678901234567890123456789: <") - } - case _ => false - } - } - - property("SI-4714: Should decode symbolic type alias name.") = { - createTemplate("SI_4715.scala") match { - case node: scala.xml.Node => { - val html = node.toString - html.contains(">:+:<") - } - case _ => false - } - } - - property("SI-4287: Default arguments of synthesized constructor") = { - val files = createTemplates("SI_4287.scala") - - files("ClassWithSugar.html") match { - case node: scala.xml.Node => { - node.toString.contains(">123<") - } - case _ => false - } - } - - property("SI-4507: Default arguments of synthesized constructor") = { - createTemplate("SI_4507.scala") match { - case node: scala.xml.Node => - ! node.toString.contains("<li>returns silently when evaluating true and true</li>") - case _ => false - } - } - - property("SI-4898: Use cases and links should not crash scaladoc") = { - createTemplate("SI_4898.scala") - true - } - - property("SI-5054: Use cases should override their original members") = - checkText("SI_5054_q1.scala")( - (None,"""def test(): Int""", true) - //Disabled because the full signature is now displayed - //(None, """def test(implicit lost: Int): Int""", false) - ) - - property("SI-5054: Use cases should keep their flags - final should not be lost") = - checkText("SI_5054_q2.scala")((None, """final def test(): Int""", true)) - - property("SI-5054: Use cases should keep their flags - implicit should not be lost") = - checkText("SI_5054_q3.scala")((None, """implicit def test(): Int""", true)) - - property("SI-5054: Use cases should keep their flags - real abstract should not be lost") = - checkText("SI_5054_q4.scala")((None, """abstract def test(): Int""", true)) - - property("SI-5054: Use cases should keep their flags - traits should not be affected") = - checkText("SI_5054_q5.scala")((None, """def test(): Int""", true)) - - property("SI-5054: Use cases should keep their flags - traits should not be affected") = - checkText("SI_5054_q6.scala")((None, """abstract def test(): Int""", true)) - - property("SI-5054: Use case individual signature test") = - checkText("SI_5054_q7.scala")( - (None, """abstract def test2(explicit: Int): Int [use case] This takes the explicit value passed.""", true), - (None, """abstract def test1(): Int [use case] This takes the implicit value in scope.""", true) - ) - - property("SI-5287: Display correct \"Definition classes\"") = - checkText("SI_5287.scala")( - (None, - """def method(): Int - [use case] The usecase explanation - [use case] The usecase explanation - Definition Classes SI_5287 SI_5287_B SI_5287_A""", true) - ) // the explanation appears twice, as small comment and full comment - - property("Comment inheritance: Correct comment inheritance for overriding") = - checkText("implicit-inheritance-override.scala")( - (Some("Base"), - """def function[T](arg1: T, arg2: String): Double - The base comment. - The base comment. And another sentence... - T the type of the first argument - arg1 The T term comment - arg2 The string comment - returns The return comment - """, true), - (Some("DerivedA"), - """def function[T](arg1: T, arg2: String): Double - Overriding the comment, the params and returns comments should stay the same. - Overriding the comment, the params and returns comments should stay the same. - T the type of the first argument - arg1 The T term comment - arg2 The string comment - returns The return comment - """, true), - (Some("DerivedB"), - """def function[T](arg1: T, arg2: String): Double - T the type of the first argument - arg1 The overridden T term comment - arg2 The overridden string comment - returns The return comment - """, true), - (Some("DerivedC"), - """def function[T](arg1: T, arg2: String): Double - T the type of the first argument - arg1 The T term comment - arg2 The string comment - returns The overridden return comment - """, true), - (Some("DerivedD"), - """def function[T](arg1: T, arg2: String): Double - T The overridden type parameter comment - arg1 The T term comment - arg2 The string comment - returns The return comment - """, true) - ) - - for (useCaseFile <- List("UseCaseInheritance", "UseCaseOverrideInheritance")) { - property("Comment inheritance: Correct comment inheritance for usecases") = - checkText("implicit-inheritance-usecase.scala")( - (Some(useCaseFile), - """def missing_arg[T](arg1: T): Double - [use case] - [use case] - T The type parameter - arg1 The T term comment - returns The return comment - """, true), - (Some(useCaseFile), - """def missing_targ(arg1: Int, arg2: String): Double - [use case] - [use case] - arg1 The T term comment - arg2 The string comment - returns The return comment - """, true), - (Some(useCaseFile), - """def overridden_arg1[T](implicit arg1: T, arg2: String): Double - [use case] - [use case] - T The type parameter - arg1 The overridden T term comment - arg2 The string comment - returns The return comment - """, true), - (Some(useCaseFile), - """def overridden_targ[T](implicit arg1: T, arg2: String): Double - [use case] - [use case] - T The overridden type parameter comment - arg1 The T term comment - arg2 The string comment - returns The return comment - """, true), - (Some(useCaseFile), - """def overridden_return[T](implicit arg1: T, arg2: String): Double - [use case] - [use case] - T The type parameter - arg1 The T term comment - arg2 The string comment - returns The overridden return comment - """, true), - (Some(useCaseFile), - """def added_arg[T](implicit arg1: T, arg2: String, arg3: Float): Double - [use case] - [use case] - T The type parameter - arg1 The T term comment - arg2 The string comment - arg3 The added float comment - returns The return comment - """, true), - (Some(useCaseFile), - """def overridden_comment[T](implicit arg1: T, arg2: String): Double - [use case] The overridden comment. - [use case] The overridden comment. - T The type parameter - arg1 The T term comment - arg2 The string comment - returns The return comment - """, true) - ) - } - - property("Comment inheritance: Correct explicit inheritance for override") = - checkText("explicit-inheritance-override.scala")( - (Some("InheritDocDerived"), - """def function[T](arg1: T, arg2: String): Double - Starting line - Starting line - The base comment. And another sentence... - The base comment. And another sentence... - Ending line - Author: StartAuthor a Scala developer EndAuthor - T StartT the type of the first argument EndT - arg1 Start1 The T term comment End1 - arg2 Start2 The string comment End2 - returns StartRet The return comment EndRet""", true), - (Some("InheritDocDerived"), - """Definition Classes InheritDocDerived → InheritDocBase - Example: StartExample function[Int](3, "something") EndExample - Version StartVer 0.0.2 EndVer - Since StartSince 0.0.1 EndSince - Exceptions thrown - SomeException StartEx if the function is not called with correct parameters EndEx - SomeOtherException StartSOE Should Warn <invalid inheritdoc annotation> EndSOE - To do StartTodo Call mom. And dad! EndTodo - Note StartNote Be careful! EndNote - See also StartSee The Manual EndSee - """, true)) - - property("Comment inheritance: Correct explicit inheritance for usecase") = - checkText("explicit-inheritance-usecase.scala")( - (Some("UseCaseInheritDoc"), - """def function[T](arg1: T, arg2: String): Double - [use case] Starting line - [use case] Starting line - The base comment. And another sentence... - The base comment. And another sentence... - Ending line - Author: StartAuthor a Scala developer EndAuthor - T StartT the type of the first argument EndT - arg1 Start1 The T term comment End1 - arg2 Start2 The string comment End2 - returns StartRet The return comment EndRet""", true), - (Some("UseCaseInheritDoc"), - """Example: StartExample function[Int](3,"something") EndExample - Version StartVer 0.0.2 EndVer - Since StartSince 0.0.1 EndSince - Exceptions thrown - SomeException StartEx if the function is not called with correct parameters EndEx - SomeOtherException StartSOE Should Warn <invalid inheritdoc annotation> EndSOE - To do StartTodo Call mom. And dad! EndTodo - Note StartNote Be careful! EndNote - See also StartSee The Manual EndSee - """, true)) - - property("Comment inheritance: Correct explicit inheritance in corner cases") = - checkText("inheritdoc-corner-cases.scala")( - (Some("D"), - """def hello1: Int - Inherited: Hello 1 comment - Inherited: Hello 1 comment - Definition Classes D → A - """, true), - (Some("D"), - """def hello2: Int - Inherited: Hello 2 comment - Inherited: Hello 2 comment - Definition Classes D → B - """, true), - (Some("G"), - """def hello1: Int - Inherited: Hello 1 comment - Inherited: Hello 1 comment - Definition Classes G → D → A - """, true), - (Some("G"), - """def hello2: Int - Inherited: Hello 2 comment - Inherited: Hello 2 comment - Definition Classes G → D → B - """, true), - (Some("I"), - """def hello1(i: Int): Unit - [use case] Inherited: Hello 1 comment - [use case] Inherited: Hello 1 comment - Definition Classes I → G → D → A - """, true) - // traits E, F and H shouldn't crash scaladoc but we don't need to check the output - ) - - property("Indentation normalization for code blocks") = { - val files = createTemplates("code-indent.scala") - - files("C.html") match { - case node: scala.xml.Node => { - val s = node.toString - s.contains("<pre>a typicial indented\ncomment on multiple\ncomment lines</pre>") && - s.contains("<pre>one liner</pre>") && - s.contains("<pre>two lines, one useful</pre>") && - s.contains("<pre>line1\nline2\nline3\nline4</pre>") && - s.contains("<pre>a ragged example\na (condition)\n the t h e n branch\nan alternative\n the e l s e branch</pre>") && - s.contains("<pre>Trait example {\n Val x = a\n Val y = b\n}</pre>") && - s.contains("<pre>l1\n\nl2\n\nl3\n\nl4\n\nl5</pre>") - } - case _ => false - } - } - - property("SI-4014: Scaladoc omits @author: no authors") = { - val noAuthors = createTemplates("SI-4014_0.scala")("Foo.html") - - noAuthors match { - case node: scala.xml.Node => { - val s = node.toString - ! s.contains("Author") - } - case _ => false - } - } - - property("SI-4014: Scaladoc omits @author: one author") = { - val oneAuthor = createTemplates("SI-4014_1.scala")("Foo.html") - - oneAuthor match { - case node: scala.xml.Node => { - val s = node.toString - s.contains("<h6>Author:</h6>") && - s.contains("<p>The Only Author</p>") - } - case _ => false - } - } - - property("SI-4014: Scaladoc omits @author: two authors") = { - val twoAuthors = createTemplates("SI-4014_2.scala")("Foo.html") - - twoAuthors match { - case node: scala.xml.Node => { - val s = node.toString - s.contains("<h6>Authors:</h6>") && - s.contains("<p>The First Author</p>") && - s.contains("<p>The Second Author</p>") - } - case _ => false - } - } - - { - val files = createTemplates("basic.scala") - //println(files) - - property("class") = files.get("com/example/p1/Clazz.html") match { - case Some(node: scala.xml.Node) => { - property("implicit conversion") = - node.toString contains "<span class=\"modifier\">implicit </span>" - - property("gt4s") = - node.toString contains "title=\"gt4s: $colon$colon\"" - - property("gt4s of a deprecated method") = - node.toString contains "title=\"gt4s: $colon$colon$colon$colon. Deprecated: " - true - } - case _ => false - } - property("package") = files.get("com/example/p1/package.html") != None - - property("package object") = files("com/example/p1/package.html") match { - case node: scala.xml.Node => - node.toString contains "com.example.p1#packageObjectMethod" - case _ => false - } - - property("lower bound") = files("com/example/p1/LowerBound.html") match { - case node: scala.xml.Node => true - case _ => false - } - - property("upper bound") = files("com/example/p1/UpperBound.html") match { - case node: scala.xml.Node => true - case _ => false - } - - property("SI-8514: No inconsistencies") = - checkText("SI-8514.scala")( - (Some("a/package"), - """class A extends AnyRef - Some doc here - Some doc here - Annotations @DeveloperApi() - """, true), - (Some("a/package"), - """class B extends AnyRef - Annotations @DeveloperApi() - """, true) - ) - } - - // SI-8144 - { - implicit class AttributesAwareNode(val node: NodeSeq) { - - def \@(attrName: String): String = - node \ ("@" + attrName) text - - def \@(attrName: String, attrValue: String): NodeSeq = - node filter { _ \ ("@" + attrName) exists (_.text == attrValue) } - } - - implicit class AssertionAwareNode(node: scala.xml.NodeSeq) { - - def assertTypeLink(expectedUrl: String): Boolean = { - val linkElement: NodeSeq = node \\ "div" \@ ("id", "definition") \\ "span" \@ ("class", "permalink") \ "a" - linkElement \@ "href" == expectedUrl && linkElement \@ "target" == "_top" - } - - def assertMemberLink(group: String)(memberName: String, expectedUrl: String): Boolean = { - val linkElement: NodeSeq = node \\ "div" \@ ("id", group) \\ "li" \@ ("name", memberName) \\ "span" \@ ("class", "permalink") \ "a" - linkElement \@ "href" == expectedUrl && linkElement \@ "target" == "_top" - } - - } - - val files = createTemplates("SI-8144.scala") - - def check(pagePath: String)(f: NodeSeq => org.scalacheck.Prop): org.scalacheck.Prop = - files(pagePath) match { - case node: scala.xml.Node => f(XMLUtil.stripGroup(node)) - case _ => false - } - - property("SI-8144: Members' permalink - package") = check("some/package.html") { node => - ("type link" |: node.assertTypeLink("../index.html#some.package")) && - ("member: some.pack" |: node.assertMemberLink("values")("some.pack", "../index.html#some.package@pack")) - } - - property("SI-8144: Members' permalink - inner package") = check("some/pack/package.html") { node => - ("type link" |: node.assertTypeLink("../../index.html#some.pack.package")) && - ("member: SomeType (object)" |: node.assertMemberLink("values")("some.pack.SomeType", "../../index.html#some.pack.package@SomeType")) && - ("member: SomeType (class)" |: node.assertMemberLink("types")("some.pack.SomeType", "../../index.html#some.pack.package@SomeTypeextendsAnyRef")) - } - - property("SI-8144: Members' permalink - companion object") = check("some/pack/SomeType$.html") { node => - ("type link" |: node.assertTypeLink("../../index.html#some.pack.SomeType$")) && - ("member: someVal" |: node.assertMemberLink("allMembers")("some.pack.SomeType#someVal", "../../index.html#some.pack.SomeType$@someVal:String")) - } - - property("SI-8144: Members' permalink - class") = check("some/pack/SomeType.html") { node => - ("type link" |: node.assertTypeLink("../../index.html#some.pack.SomeType")) && - ("constructor " |: node.assertMemberLink("constructors")("some.pack.SomeType#<init>", "../../index.html#some.pack.SomeType@<init>(arg:String):some.pack.SomeType")) && - ( "member: type TypeAlias" |: node.assertMemberLink("types")("some.pack.SomeType.TypeAlias", "../../index.html#some.pack.SomeType@TypeAlias=String")) && - ( "member: def >#<():Int " |: node.assertMemberLink("values")("some.pack.SomeType#>#<", "../../index.html#some.pack.SomeType@>#<():Int")) && - ( "member: def >@<():TypeAlias " |: node.assertMemberLink("values")("some.pack.SomeType#>@<", "../../index.html#some.pack.SomeType@>@<():SomeType.this.TypeAlias")) - } - - } -} diff --git a/test/scaladoc/scalacheck/IndexScriptTest.scala b/test/scaladoc/scalacheck/IndexScriptTest.scala deleted file mode 100644 index b8b9f92965..0000000000 --- a/test/scaladoc/scalacheck/IndexScriptTest.scala +++ /dev/null @@ -1,58 +0,0 @@ -import org.scalacheck._ -import org.scalacheck.Prop._ - -import scala.tools.nsc.doc -import scala.tools.nsc.doc.html.page.IndexScript -import java.net.{URLClassLoader, URLDecoder} - -object Test extends Properties("IndexScript") { - - def getClasspath = { - // these things can be tricky - // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths - // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. - // this test _will_ fail again some time in the future. - // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader - val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] - val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) - paths mkString java.io.File.pathSeparator - } - - val docFactory = { - val settings = new doc.Settings({Console.err.println(_)}) - settings.scaladocQuietRun = true - settings.nowarn.value = true - settings.classpath.value = getClasspath - val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) - new doc.DocFactory(reporter, settings) - } - - val indexModelFactory = doc.model.IndexModelFactory - - def createIndexScript(path: String) = - docFactory.makeUniverse(Left(List(path))) match { - case Some(universe) => { - val index = new IndexScript(universe, - indexModelFactory.makeIndex(universe)) - Some(index) - } - case _ => - None - } - - property("allPackages") = { - createIndexScript("src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala") match { - case Some(index) => - index.allPackages.map(_.toString) == List( - "scala", - "scala.tools", - "scala.tools.nsc", - "scala.tools.nsc.doc", - "scala.tools.nsc.doc.html", - "scala.tools.nsc.doc.html.page" - ) - case None => - false - } - } -} diff --git a/test/scaladoc/scalacheck/IndexTest.scala b/test/scaladoc/scalacheck/IndexTest.scala deleted file mode 100644 index 7dbd2103a6..0000000000 --- a/test/scaladoc/scalacheck/IndexTest.scala +++ /dev/null @@ -1,95 +0,0 @@ -import org.scalacheck._ -import org.scalacheck.Prop._ - -import scala.tools.nsc.doc -import scala.tools.nsc.doc.html.page.Index -import java.net.{URLClassLoader, URLDecoder} - -object Test extends Properties("Index") { - - def getClasspath = { - // these things can be tricky - // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths - // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. - // this test _will_ fail again some time in the future. - // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader - val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] - val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) - paths mkString java.io.File.pathSeparator - } - - val docFactory = { - val settings = new doc.Settings({Console.err.println(_)}) - settings.scaladocQuietRun = true - settings.nowarn.value = true - settings.classpath.value = getClasspath - - val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) - new doc.DocFactory(reporter, settings) - } - - val indexModelFactory = doc.model.IndexModelFactory - - def createIndex(path: String): Option[Index] = { - - val maybeUniverse = { - //val stream = new java.io.ByteArrayOutputStream - //val original = Console.out - //Console.setOut(stream) - - val result = docFactory.makeUniverse(Left(List(path))) - - // assert(stream.toString == "model contains 2 documentable templates\n") - //Console.setOut(original) - - result - } - - maybeUniverse match { - case Some(universe) => { - val index = new Index(universe, indexModelFactory.makeIndex(universe)) - return Some(index) - } - case _ => return None - } - - } - - property("path") = { - createIndex("src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala") match { - case Some(index) => - index.path == List("index.html") - case None => false - } - } - - property("title") = { - createIndex("src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala") match { - case Some(index) => - index.title == "" - - case None => false - } - } - property("browser contains a script element") = { - createIndex("src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala") match { - case Some(index) => - (index.browser \ "script").size == 1 - - case None => false - } - } - property("package objects in index") = { - createIndex("test/scaladoc/resources/SI-5558.scala") match { - case Some(index) => - index.index.firstLetterIndex('f') isDefinedAt "foo" - case None => false - } - } - property("index should report if there are deprecated members") = { - createIndex("test/scaladoc/resources/SI-4476.scala") match { - case Some(indexPage) => indexPage.index.hasDeprecatedMembers - case None => false - } - } -} |