Update scalafmt-core to 3.7.15 (#513)

scala-steward · web-flow · commit c4dab9dbf4fd · 2023-10-28T03:20:36.000-07:00
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
@@ -1,2 +1,5 @@
 # Scala Steward: Reformat with scalafmt 3.5.9
 ff8ca52d610ca63ee0ab4fcfb5d79da13a1250b1
+
+# Scala Steward: Reformat with scalafmt 3.7.15
+8fa2251b493a78759fc04a2f74189b9f8bdc07c4
diff --git a/.scalafmt.conf b/.scalafmt.conf
@@ -7,5 +7,5 @@ rewrite.rules = [RedundantBraces, RedundantParens, SortImports]
 spaces.inImportCurlyBraces = true
 indentOperator.preset = spray
 
-version=3.7.14
+version=3.7.15
 
diff --git a/common/src/main/scala/org/mockito/stubbing/ScalaFirstStubbing.scala b/common/src/main/scala/org/mockito/stubbing/ScalaFirstStubbing.scala
@@ -27,7 +27,7 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[
    * Sets consecutive return one or more values to be returned when the method is called. E.g: <pre class="code"><code class="scala"> when(mock.someMethod) thenReturn 1
    * </code></pre> <pre class="code"><code class="scala"> when(mock.someMethod) thenReturn (1, 2, 3) </code></pre>
    *
-   * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@link org.mockito.MockitoSugar#when}
+   * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@@linkorg.mockito.MockitoSugar#when}
    *
    * @param value
    *   first return value
@@ -43,7 +43,7 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[
    * </code></pre> <pre class="code"><code class="java"> when(mock.someMethod) thenThrow (new RuntimeException, new OtherException) </code></pre>
    *
    * <p> You can specify throwables to be thrown for consecutive calls. In that case the last throwable determines the behavior of further consecutive calls. <p> If throwable is
-   * null then exception will be thrown. <p> See examples in javadoc for {@link org.mockito.MockitoSugar#when}
+   * null then exception will be thrown. <p> See examples in javadoc for {@@linkorg.mockito.MockitoSugar#when}
    *
    * @param throwables
    *   to be thrown on method invocation
@@ -57,7 +57,7 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[
    * </code></pre>
    *
    * <p> If the throwable class is a checked exception then it has to match one of the checked exceptions of the stubbed method signature. <p> If throwable is null then exception
-   * will be thrown. <p> See examples in javadoc for {@link Mockito#when}
+   * will be thrown. <p> See examples in javadoc for {@@linkMockito#when}
    *
    * <p>Note depending on the JVM, stack trace information may not be available in the generated throwable instance. If you require stack trace information, use {@link
    * OngoingStubbing#thenThrow(Throwable...)} instead.
@@ -80,9 +80,9 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[
    *
    * // calls real method: mock.someMethod();
    *
-   * </code></pre> See also javadoc {@link Mockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The
+   * </code></pre> See also javadoc {@@linkMockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The
    * reason is it guarantees real methods are called against correctly constructed object because you're responsible for constructing the object passed to spy() method. <p> See
-   * examples in javadoc for {@link Mockito#when}
+   * examples in javadoc for {@@linkMockito#when}
    *
    * @return
    *   object that allows stubbing consecutive calls
diff --git a/common/src/main/scala/org/mockito/stubbing/ScalaOngoingStubbing.scala b/common/src/main/scala/org/mockito/stubbing/ScalaOngoingStubbing.scala
@@ -15,7 +15,7 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin
   /**
    * Sets consecutive return values to be returned when the method is called. E.g: <pre class="code"><code class="java"> when(mock.someMethod()).thenReturn(1, 2, 3); </code></pre>
    *
-   * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@link Mockito#when}
+   * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@@linkMockito#when}
    *
    * @param value
    *   first return value
@@ -32,7 +32,7 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin
    *
    * If throwables contain a checked exception then it has to match one of the checked exceptions of method signature. <p> You can specify throwables to be thrown for consecutive
    * calls. In that case the last throwable determines the behavior of further consecutive calls. <p> If throwable is null then exception will be thrown. <p> See examples in
-   * javadoc for {@link Mockito#when}
+   * javadoc for {@@linkMockito#when}
    *
    * @param throwables
    *   to be thrown on method invocation
@@ -46,7 +46,7 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin
    * </code></pre>
    *
    * <p> If the throwable class is a checked exception then it has to match one of the checked exceptions of the stubbed method signature. <p> If throwable is null then exception
-   * will be thrown. <p> See examples in javadoc for {@link Mockito#when}
+   * will be thrown. <p> See examples in javadoc for {@@linkMockito#when}
    *
    * <p>Note depending on the JVM, stack trace information may not be available in the generated throwable instance. If you require stack trace information, use {@link
    * OngoingStubbing#thenThrow(Throwable...)} instead.
@@ -69,9 +69,9 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin
    *
    * // calls real method: mock.someMethod();
    *
-   * </code></pre> See also javadoc {@link Mockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The
+   * </code></pre> See also javadoc {@@linkMockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The
    * reason is it guarantees real methods are called against correctly constructed object because you're responsible for constructing the object passed to spy() method. <p> See
-   * examples in javadoc for {@link Mockito#when}
+   * examples in javadoc for {@@linkMockito#when}
    *
    * @return
    *   object that allows stubbing consecutive calls

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[`
`27`	`27`	`* Sets consecutive return one or more values to be returned when the method is called. E.g: <pre class="code"><code class="scala"> when(mock.someMethod) thenReturn 1`
`28`	`28`	`* </code></pre> <pre class="code"><code class="scala"> when(mock.someMethod) thenReturn (1, 2, 3) </code></pre>`
`29`	`29`	`*`
`30`		`- * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@link org.mockito.MockitoSugar#when}`
	`30`	`+ * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@@linkorg.mockito.MockitoSugar#when}`
`31`	`31`	`*`
`32`	`32`	`* @param value`
`33`	`33`	`* first return value`
`@@ -43,7 +43,7 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[`
`43`	`43`	`* </code></pre> <pre class="code"><code class="java"> when(mock.someMethod) thenThrow (new RuntimeException, new OtherException) </code></pre>`
`44`	`44`	`*`
`45`	`45`	`* <p> You can specify throwables to be thrown for consecutive calls. In that case the last throwable determines the behavior of further consecutive calls. <p> If throwable is`
`46`		`- * null then exception will be thrown. <p> See examples in javadoc for {@link org.mockito.MockitoSugar#when}`
	`46`	`+ * null then exception will be thrown. <p> See examples in javadoc for {@@linkorg.mockito.MockitoSugar#when}`
`47`	`47`	`*`
`48`	`48`	`* @param throwables`
`49`	`49`	`* to be thrown on method invocation`
`@@ -57,7 +57,7 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[`
`57`	`57`	`* </code></pre>`
`58`	`58`	`*`
`59`	`59`	`* <p> If the throwable class is a checked exception then it has to match one of the checked exceptions of the stubbed method signature. <p> If throwable is null then exception`
`60`		`- * will be thrown. <p> See examples in javadoc for {@link Mockito#when}`
	`60`	`+ * will be thrown. <p> See examples in javadoc for {@@linkMockito#when}`
`61`	`61`	`*`
`62`	`62`	`* <p>Note depending on the JVM, stack trace information may not be available in the generated throwable instance. If you require stack trace information, use {@link`
`63`	`63`	`* OngoingStubbing#thenThrow(Throwable...)} instead.`
`@@ -80,9 +80,9 @@ case class ScalaFirstStubbing[T: ValueClassExtractor](delegate: OngoingStubbing[`
`80`	`80`	`*`
`81`	`81`	`* // calls real method: mock.someMethod();`
`82`	`82`	`*`
`83`		`- * </code></pre> See also javadoc {@link Mockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The`
	`83`	`+ * </code></pre> See also javadoc {@@linkMockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The`
`84`	`84`	`* reason is it guarantees real methods are called against correctly constructed object because you're responsible for constructing the object passed to spy() method. <p> See`
`85`		`- * examples in javadoc for {@link Mockito#when}`
	`85`	`+ * examples in javadoc for {@@linkMockito#when}`
`86`	`86`	`*`
`87`	`87`	`* @return`
`88`	`88`	`* object that allows stubbing consecutive calls`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin`
`15`	`15`	`/**`
`16`	`16`	`* Sets consecutive return values to be returned when the method is called. E.g: <pre class="code"><code class="java"> when(mock.someMethod()).thenReturn(1, 2, 3); </code></pre>`
`17`	`17`	`*`
`18`		`- * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@link Mockito#when}`
	`18`	`+ * Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls. <p> See examples in javadoc for {@@linkMockito#when}`
`19`	`19`	`*`
`20`	`20`	`* @param value`
`21`	`21`	`* first return value`
`@@ -32,7 +32,7 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin`
`32`	`32`	`*`
`33`	`33`	`* If throwables contain a checked exception then it has to match one of the checked exceptions of method signature. <p> You can specify throwables to be thrown for consecutive`
`34`	`34`	`* calls. In that case the last throwable determines the behavior of further consecutive calls. <p> If throwable is null then exception will be thrown. <p> See examples in`
`35`		`- * javadoc for {@link Mockito#when}`
	`35`	`+ * javadoc for {@@linkMockito#when}`
`36`	`36`	`*`
`37`	`37`	`* @param throwables`
`38`	`38`	`* to be thrown on method invocation`
`@@ -46,7 +46,7 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin`
`46`	`46`	`* </code></pre>`
`47`	`47`	`*`
`48`	`48`	`* <p> If the throwable class is a checked exception then it has to match one of the checked exceptions of the stubbed method signature. <p> If throwable is null then exception`
`49`		`- * will be thrown. <p> See examples in javadoc for {@link Mockito#when}`
	`49`	`+ * will be thrown. <p> See examples in javadoc for {@@linkMockito#when}`
`50`	`50`	`*`
`51`	`51`	`* <p>Note depending on the JVM, stack trace information may not be available in the generated throwable instance. If you require stack trace information, use {@link`
`52`	`52`	`* OngoingStubbing#thenThrow(Throwable...)} instead.`
`@@ -69,9 +69,9 @@ case class ScalaOngoingStubbing[T: ValueClassExtractor](delegate: OngoingStubbin`
`69`	`69`	`*`
`70`	`70`	`* // calls real method: mock.someMethod();`
`71`	`71`	`*`
`72`		`- * </code></pre> See also javadoc {@link Mockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The`
	`72`	`+ * </code></pre> See also javadoc {@@linkMockito#spy(Object)} to find out more about partial mocks. <b>Mockito.spy() is a recommended way of creating partial mocks.</b> The`
`73`	`73`	`* reason is it guarantees real methods are called against correctly constructed object because you're responsible for constructing the object passed to spy() method. <p> See`
`74`		`- * examples in javadoc for {@link Mockito#when}`
	`74`	`+ * examples in javadoc for {@@linkMockito#when}`
`75`	`75`	`*`
`76`	`76`	`* @return`
`77`	`77`	`* object that allows stubbing consecutive calls`