raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

Rename akka to pekko in configuration (#63)

Browse source 
Resolves https://github.com/apache/incubator-pekko/issues/54
This commit is contained in:
Greg Methvin 2022-12-02 04:53:48 -08:00 • committed by GitHub
parent 708da8caec
commit 3d93dbcb81
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1047 changed files with 4472 additions and 4464 deletions
Download patch file Download diff file Expand all files Collapse all files

16
.github/workflows/build-test-prValidation.yml vendored
View file

@ -55,14 +55,14 @@ jobs:
- name: sbt validatePullRequest
run: |-
sbtx -jvm-opts .jvmopts-ci \
-Dakka.mima.enabled=false \
-Dakka.test.multi-in-test=false \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,timing \
-Dakka.cluster.assert=on \
-Dpekko.mima.enabled=false \
-Dpekko.test.multi-in-test=false \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.exclude=gh-exclude,timing \
-Dpekko.cluster.assert=on \
-Dsbt.override.build.repos=false \
-Dakka.test.multi-node=false \
-Dpekko.test.multi-node=false \
-Dsbt.log.noformat=false \
-Dakka.log.timestamps=true \
-Dpekko.log.timestamps=true \
validateCompile validatePullRequest

2
.github/workflows/link-validator.yml vendored
View file

@ -28,7 +28,7 @@ jobs:
uses: coursier/cache-action@v6.4.0
- name: create the Akka site
run: sbt -Dakka.genjavadoc.enabled=true "Javaunidoc/doc; Compile/unidoc; docs/paradox"
run: sbt -Dpekko.genjavadoc.enabled=true "Javaunidoc/doc; Compile/unidoc; docs/paradox"
- name: Install Coursier command line tool
run: curl -fLo cs https://git.io/coursier-cli-linux && chmod +x cs && ./cs

30
.github/workflows/multi-node.yml vendored
View file

@ -52,14 +52,14 @@ jobs:
run: |
cat multi-node-test.hosts
sbtx -jvm-opts .jvmopts-ci \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,timing \
-Dakka.cluster.assert=on \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.exclude=gh-exclude,timing \
-Dpekko.cluster.assert=on \
-Dsbt.override.build.repos=false \
-Dakka.test.multi-node=true \
-Dakka.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \
-Dakka.test.multi-node.java=${JAVA_HOME}/bin/java \
-Dpekko.test.multi-node=true \
-Dpekko.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \
-Dpekko.test.multi-node.java=${JAVA_HOME}/bin/java \
-Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms512M \
-Dmultinode.Xmx512M \
@ -136,15 +136,15 @@ jobs:
run: |
cat multi-node-test.hosts
sbtx -jvm-opts .jvmopts-ci \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.cluster.assert=on \
-Dakka.remote.artery.transport=aeron-udp \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.cluster.assert=on \
-Dpekko.remote.artery.transport=aeron-udp \
-Dsbt.override.build.repos=false \
-Dakka.test.tags.exclude=gh-exclude,gh-exclude-aeron,timing \
-Dakka.test.multi-node=true \
-Dakka.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \
-Dakka.test.multi-node.java=${JAVA_HOME}/bin/java \
-Dpekko.test.tags.exclude=gh-exclude,gh-exclude-aeron,timing \
-Dpekko.test.multi-node=true \
-Dpekko.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \
-Dpekko.test.multi-node.java=${JAVA_HOME}/bin/java \
-Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms512M \
-Dmultinode.Xmx512M \

52
.github/workflows/nightly-builds.yml vendored
View file

@ -30,12 +30,12 @@ jobs:
run: |-
sbtx -jvm-opts .jvmopts-ci \
-Djava.security.egd=file:/dev/./urandom \
-Dakka.test.sigar=true \
-Dakka.cluster.assert=on \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,timing \
-Dakka.log.timestamps=true \
-Dpekko.test.sigar=true \
-Dpekko.cluster.assert=on \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.exclude=gh-exclude,timing \
-Dpekko.log.timestamps=true \
-Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms256M \
-Dmultinode.Xmx256M \
@ -100,12 +100,12 @@ jobs:
run: |-
sbtx -jvm-opts .jvmopts-ci \
-Djava.security.egd=file:/dev/./urandom \
-Dakka.remote.artery.enabled=off \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,timing \
-Dakka.test.multi-in-test=false \
-Dakka.cluster.assert=on \
-Dpekko.remote.artery.enabled=off \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.exclude=gh-exclude,timing \
-Dpekko.test.multi-in-test=false \
-Dpekko.cluster.assert=on \
clean ${{ matrix.command }}
# comment out email actions until we have an email address to use (and we need to get INFRA to whitelist dawidd6/action-send-mail)
@ -161,12 +161,12 @@ jobs:
# note that this is not running any multi-jvm tests because multi-in-test=false
run: |-
sbtx -jvm-opts .jvmopts-ci \
-Dakka.cluster.assert=on \
-Dakka.log.timestamps=true \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,timing \
-Dakka.test.multi-in-test=false \
-Dpekko.cluster.assert=on \
-Dpekko.log.timestamps=true \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.exclude=gh-exclude,timing \
-Dpekko.test.multi-in-test=false \
${{ matrix.extraOpts }} \
clean "+~ ${{ matrix.scalaVersion }} test" checkTestsHaveRun
@ -195,7 +195,7 @@ jobs:
run: |-
sudo apt-get install graphviz
sbtx -jvm-opts .jvmopts-ci \
-Dakka.genjavadoc.enabled=true \
-Dpekko.genjavadoc.enabled=true \
"+~ ${{ matrix.scalaVersion }} doc"
- name: Publish
@ -204,7 +204,7 @@ jobs:
run: |-
sudo apt-get install graphviz
sbtx -jvm-opts .jvmopts-ci \
-Dakka.build.scalaVersion=${{ matrix.scalaVersion }} \
-Dpekko.build.scalaVersion=${{ matrix.scalaVersion }} \
"+~ ${{ matrix.scalaVersion }} publishLocal publishM2"
# comment out email actions until we have an email address to use (and we need to get INFRA to whitelist dawidd6/action-send-mail)
@ -253,12 +253,12 @@ jobs:
run: |-
sbtx -jvm-opts .jvmopts-ci \
-Djava.security.egd=file:/dev/./urandom \
-Dakka.remote.artery.transport=aeron-udp \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,gh-exclude-aeron,timing \
-Dakka.test.multi-in-test=false \
-Dakka.cluster.assert=on \
-Dpekko.remote.artery.transport=aeron-udp \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.exclude=gh-exclude,gh-exclude-aeron,timing \
-Dpekko.test.multi-in-test=false \
-Dpekko.cluster.assert=on \
-Daeron.dir=/opt/volumes/media-driver \
-Daeron.term.buffer.length=33554432 \
clean ${{ matrix.command }}

2
.github/workflows/publish-docs.yml vendored
View file

@ -33,7 +33,7 @@ jobs:
chmod 600 /tmp/id_rsa
ssh-add /tmp/id_rsa
# using Scala 2.13 here to avoid the infamous problem with missing AskSupport in classpath
sbt -Dakka.genjavadoc.enabled=true "+~ 2.13 publishRsync"
sbt -Dpekko.genjavadoc.enabled=true "+~ 2.13 publishRsync"
env:
SCP_SECRET: ${{ secrets.SCP_SECRET }}

10
.github/workflows/scala3-build.yml vendored
View file

@ -49,11 +49,11 @@ jobs:
# note that this is not running any multi-jvm tests (yet) because multi-in-test=false
run: |
sbtx -jvm-opts .jvmopts-ci \
-Dakka.log.timestamps=true \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.multi-in-test=false \
-Dakka.test.tags.exclude=gh-exclude,timing \
-Dpekko.log.timestamps=true \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.multi-in-test=false \
-Dpekko.test.tags.exclude=gh-exclude,timing \
-Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms256M \
-Dmultinode.Xmx256M \

12
.github/workflows/timing-tests.yml vendored
View file

@ -30,12 +30,12 @@ jobs:
run: |-
sbtx -jvm-opts .jvmopts-ci \
-Djava.security.egd=file:/dev/./urandom \
-Dakka.cluster.assert=on \
-Dakka.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.only=timing \
-Dakka.log.timestamps=true \
-Dakka.test.multi-in-test=false \
-Dpekko.cluster.assert=on \
-Dpekko.test.timefactor=2 \
-Dpekko.actor.testkit.typed.timefactor=2 \
-Dpekko.test.tags.only=timing \
-Dpekko.log.timestamps=true \
-Dpekko.test.multi-in-test=false \
-Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms256M \
-Dmultinode.Xmx256M \

2
.jvmopts-ci
View file

@ -12,4 +12,4 @@
-XX:MetaspaceSize=512M
-XX:-ClassUnloadingWithConcurrentMark
-Djava.security.egd=file:/dev/./urandom
-Dakka.ci-server=true
-Dpekko.ci-server=true

10
CONTRIBUTING.md
View file

@ -347,7 +347,7 @@ For further hints on how to disambiguate links in ScalaDoc comments see
[this StackOverflow answer](https://stackoverflow.com/a/31569861/354132),
though note that this syntax may not correctly render as Javadoc.
The Scaladoc tool needs the `dot` command from the [Graphviz](https://graphviz.org/#download) software package to be installed to avoid errors. You can disable the diagram generation by adding the flag `-Dakka.scaladoc.diagrams=false`. After installing Graphviz, make sure you add the toolset to the `PATH` (definitely on Windows).
The Scaladoc tool needs the `dot` command from the [Graphviz](https://graphviz.org/#download) software package to be installed to avoid errors. You can disable the diagram generation by adding the flag `-Dpekko.scaladoc.diagrams=false`. After installing Graphviz, make sure you add the toolset to the `PATH` (definitely on Windows).
#### JavaDoc
@ -357,7 +357,7 @@ Generating JavaDoc is not enabled by default, as it's not needed on day-to-day d
If you'd like to check if your links and formatting look good in JavaDoc (and not only in ScalaDoc), you can generate it by running:
```shell
sbt -Dakka.genjavadoc.enabled=true Javaunidoc/doc
sbt -Dpekko.genjavadoc.enabled=true Javaunidoc/doc
```
Which will generate JavaDoc style docs in `./target/javaunidoc/index.html`. This requires a JDK version 11 or later.
@ -431,13 +431,13 @@ Also, tests tagged as `PerformanceTest`, `TimingTest`, `LongRunningTest`, and al
You can exclude the same kind of tests in your local build by starting sbt with:
```shell
sbt -Dakka.test.tags.exclude=performance,timing,long-running -Dakka.test.multi-in-test=false
sbt -Dpekko.test.tags.exclude=performance,timing,long-running -Dpekko.test.multi-in-test=false
```
It is also possible to exclude groups of test by their names. For example:
```shell
sbt -Dakka.test.names.exclude=akka.cluster.Stress
sbt -Dpekko.test.names.exclude=akka.cluster.Stress
```
Will exclude any tests that have names containing `akka.cluster.Stress`.
@ -476,7 +476,7 @@ In addition to formatting, the Pekko build enforces code discipline through a se
to any non-empty string value when starting up sbt:
```shell
sbt -Dakka.no.discipline=youbet
sbt -Dpekko.no.discipline=youbet
```
PR validation includes the discipline flags and hence may fail if the flags were disabled during development. Make sure you compile your code at least once with discipline enabled before sending a PR.

4
akka-actor-testkit-typed/src/main/resources/reference.conf
View file

@ -1,11 +1,11 @@
##################################################
# Akka Actor Typed Testkit Reference Config File #
# Pekko Actor Typed Testkit Reference Config File #
##################################################
# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.
akka.actor.testkit.typed {
pekko.actor.testkit.typed {
# Factor by which to scale timeouts during tests, e.g. to account for shared
# build system load.
timefactor = 1.0

10
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala
View file

@ -18,27 +18,27 @@ import pekko.util.Timeout
object TestKitSettings {
/**
* Reads configuration settings from `akka.actor.testkit.typed` section.
* Reads configuration settings from `pekko.actor.testkit.typed` section.
*/
def apply(system: ActorSystem[_]): TestKitSettings =
Ext(system).settings
/**
* Reads configuration settings from given `Config` that
* must have the same layout as the `akka.actor.testkit.typed` section.
* must have the same layout as the `pekko.actor.testkit.typed` section.
*/
def apply(config: Config): TestKitSettings =
new TestKitSettings(config)
/**
* Java API: Reads configuration settings from `akka.actor.testkit.typed` section.
* Java API: Reads configuration settings from `pekko.actor.testkit.typed` section.
*/
def create(system: ActorSystem[_]): TestKitSettings =
apply(system)
/**
* Reads configuration settings from given `Config` that
* must have the same layout as the `akka.actor.testkit.typed` section.
* must have the same layout as the `pekko.actor.testkit.typed` section.
*/
def create(config: Config): TestKitSettings =
new TestKitSettings(config)
@ -49,7 +49,7 @@ object TestKitSettings {
}
private class Ext(system: ActorSystem[_]) extends Extension {
val settings: TestKitSettings = TestKitSettings(system.settings.config.getConfig("akka.actor.testkit.typed"))
val settings: TestKitSettings = TestKitSettings(system.settings.config.getConfig("pekko.actor.testkit.typed"))
}
}

4
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/LoggingTestKit.scala
View file

@ -32,7 +32,7 @@ import pekko.annotation.DoNotInherit
* outside (after) the `intercept` thunk and it has already found expected number.
*
* When occurrences is 0 it will look for unexpected matching events, and then it will
* also look for excess messages during the configured `akka.actor.testkit.typed.expect-no-message-default`
* also look for excess messages during the configured `pekko.actor.testkit.typed.expect-no-message-default`
* duration.
*/
def withOccurrences(newOccurrences: Int): LoggingTestKit
@ -95,7 +95,7 @@ import pekko.annotation.DoNotInherit
/**
* Run the given code block and assert that the criteria of this `LoggingTestKit` has
* matched within the configured `akka.actor.testkit.typed.filter-leeway`
* matched within the configured `pekko.actor.testkit.typed.filter-leeway`
* as often as requested by its `occurrences` parameter specifies.
*
* Care is taken to remove the testkit when the block is finished or aborted.

20
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/TestProbe.scala
View file

@ -85,7 +85,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
/**
* Obtain time remaining for execution of the innermost enclosing `within`
* block or missing that it returns the properly dilated default for this
* case from settings (key "akka.actor.testkit.typed.single-expect-default").
* case from settings (key "pekko.actor.testkit.typed.single-expect-default").
*/
def getRemainingOrDefault: Duration
@ -108,7 +108,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
* take maximum wait times are available in a version which implicitly uses
* the remaining time governed by the innermost enclosing `within` block.
*
* Note that the max timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor",
* Note that the max timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor",
* while the min Duration is not.
*
* {{{
@ -156,8 +156,8 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
def expectNoMessage(max: Duration): Unit
/**
* Assert that no message is received. Waits for the default period configured as `akka.actor.testkit.typed.expect-no-message-default`.
* That timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Assert that no message is received. Waits for the default period configured as `pekko.actor.testkit.typed.expect-no-message-default`.
* That timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def expectNoMessage(): Unit
@ -170,7 +170,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
/**
* Wait for a message of type M and return it when it arrives, or fail if the `max` timeout is hit.
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def expectMessageClass[T <: M](clazz: Class[T], max: Duration): T
@ -193,7 +193,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
/**
* Receive `n` messages in a row before the given deadline.
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def receiveSeveralMessages(n: Int, max: Duration): JList[M]
@ -211,7 +211,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
* partial function).
*
* @param max Max total time without the fisher function returning `CompleteFishing` before failing.
* The timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* The timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
* @return The messages accepted in the order they arrived
*/
def fishForMessage(max: Duration, fisher: java.util.function.Function[M, FishingOutcome]): java.util.List[M]
@ -228,7 +228,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
* Expect the given actor to be stopped or stop within the given timeout or
* throw an [[AssertionError]].
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def expectTerminated[U](actorRef: ActorRef[U], max: Duration): Unit
@ -243,7 +243,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
*
* If the `max` timeout expires the last exception is thrown.
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def awaitAssert[A](max: Duration, interval: Duration, creator: Creator[A]): A
@ -253,7 +253,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
*
* If the `max` timeout expires the last exception is thrown.
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def awaitAssert[A](max: Duration, creator: Creator[A]): A

6
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/scaladsl/LoggingTestKit.scala
View file

@ -32,7 +32,7 @@ import pekko.annotation.DoNotInherit
* outside (after) the `expect` thunk and it has already found expected number.
*
* When occurrences is 0 it will look for unexpected matching events, and then it will
* also look for excess messages during the configured `akka.actor.testkit.typed.expect-no-message-default`
* also look for excess messages during the configured `pekko.actor.testkit.typed.expect-no-message-default`
* duration.
*/
def withOccurrences(newOccurrences: Int): LoggingTestKit
@ -94,7 +94,7 @@ import pekko.annotation.DoNotInherit
/**
* Run the given code block and assert that the criteria of this `LoggingTestKit` has
* matched within the configured `akka.actor.testkit.typed.filter-leeway`
* matched within the configured `pekko.actor.testkit.typed.filter-leeway`
* as often as requested by its `occurrences` parameter specifies.
*
* Care is taken to remove the testkit when the block is finished or aborted.
@ -103,7 +103,7 @@ import pekko.annotation.DoNotInherit
/**
* Run the given code block and assert that the criteria of this `LoggingTestKit` has
* matched within the configured `akka.actor.testkit.typed.filter-leeway`
* matched within the configured `pekko.actor.testkit.typed.filter-leeway`
* as often as requested by its `occurrences` parameter specifies.
*
* Care is taken to remove the testkit when the block is finished or aborted.

2
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/scaladsl/ManualTime.scala
View file

@ -26,7 +26,7 @@ object ManualTime {
*/
val config: Config =
ConfigFactory.parseString(
"""akka.scheduler.implementation = "org.apache.pekko.testkit.ExplicitlyTriggeredScheduler"""")
"""pekko.scheduler.implementation = "org.apache.pekko.testkit.ExplicitlyTriggeredScheduler"""")
/**
* Access the manual scheduler, note that you need to setup the actor system/testkit with [[ManualTime.config]]

14
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/scaladsl/TestProbe.scala
View file

@ -71,7 +71,7 @@ object TestProbe {
/**
* Obtain time remaining for execution of the innermost enclosing `within`
* block or missing that it returns the properly dilated default for this
* case from settings (key "akka.actor.testkit.typed.single-expect-default").
* case from settings (key "pekko.actor.testkit.typed.single-expect-default").
*/
def remainingOrDefault: FiniteDuration
@ -94,7 +94,7 @@ object TestProbe {
* take maximum wait times are available in a version which implicitly uses
* the remaining time governed by the innermost enclosing `within` block.
*
* Note that the max timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor",
* Note that the max timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor",
* while the min Duration is not.
*
* {{{
@ -141,8 +141,8 @@ object TestProbe {
def expectNoMessage(max: FiniteDuration): Unit
/**
* Assert that no message is received. Waits for the default period configured as `akka.actor.testkit.typed.expect-no-message-default`.
* That timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Assert that no message is received. Waits for the default period configured as `pekko.actor.testkit.typed.expect-no-message-default`.
* That timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def expectNoMessage(): Unit
@ -175,7 +175,7 @@ object TestProbe {
/**
* Receive `n` messages in a row before the given deadline.
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def receiveMessages(n: Int, max: FiniteDuration): immutable.Seq[M]
@ -194,7 +194,7 @@ object TestProbe {
* partial function).
*
* @param max Max total time without the fisher function returning `CompleteFishing` before failing.
* The timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* The timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
* @return The messages accepted in the order they arrived
*/
def fishForMessage(max: FiniteDuration, hint: String)(fisher: M => FishingOutcome): immutable.Seq[M]
@ -231,7 +231,7 @@ object TestProbe {
*
* If the `max` timeout expires the last exception is thrown.
*
* Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".
* Note that the timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/
def awaitAssert[A](a: => A, max: FiniteDuration, interval: FiniteDuration): A

2
akka-actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/scaladsl/package.scala
View file

@ -10,7 +10,7 @@ package object scaladsl {
/**
* Scala API. Scale timeouts (durations) during tests with the configured
* 'akka.actor.testkit.typed.timefactor'.
* 'pekko.actor.testkit.typed.timefactor'.
* Implicit class providing `dilated` method.
*
* {{{

4
akka-actor-testkit-typed/src/test/java/jdocs/org/apache/pekko/actor/testkit/typed/javadsl/TestConfigExample.java
View file

@ -19,12 +19,12 @@ public class TestConfigExample {
;
// #parse-string
ConfigFactory.parseString("akka.loglevel = DEBUG \n" + "akka.log-config-on-start = on \n")
ConfigFactory.parseString("pekko.loglevel = DEBUG \n" + "pekko.log-config-on-start = on \n")
// #parse-string
;
// #fallback-application-conf
ConfigFactory.parseString("akka.loglevel = DEBUG \n" + "akka.log-config-on-start = on \n")
ConfigFactory.parseString("pekko.loglevel = DEBUG \n" + "pekko.log-config-on-start = on \n")
.withFallback(ConfigFactory.load())
// #fallback-application-conf
;

8
akka-actor-testkit-typed/src/test/scala/docs/org/apache/pekko/actor/testkit/typed/scaladsl/TestConfigExample.scala
View file

@ -16,15 +16,15 @@ object TestConfigExample {
// #parse-string
ConfigFactory.parseString("""
akka.loglevel = DEBUG
akka.log-config-on-start = on
pekko.loglevel = DEBUG
pekko.log-config-on-start = on
""")
// #parse-string
// #fallback-application-conf
ConfigFactory.parseString("""
akka.loglevel = DEBUG
akka.log-config-on-start = on
pekko.loglevel = DEBUG
pekko.log-config-on-start = on
""").withFallback(ConfigFactory.load())
// #fallback-application-conf
}

2
akka-actor-testkit-typed/src/test/scala/org/apache/pekko/actor/testkit/typed/scaladsl/TestAppenderSpec.scala
View file

@ -17,7 +17,7 @@ class TestAppenderSpec
extends ScalaTestWithActorTestKit(
"""
# increase to avoid spurious failures in "find unexpected async events withOccurrences(0)"
akka.actor.testkit.typed.expect-no-message-default = 1000 ms
pekko.actor.testkit.typed.expect-no-message-default = 1000 ms
""")
with AnyWordSpecLike
with LogCapturing {

4
akka-actor-testkit-typed/src/test/scala/org/apache/pekko/actor/testkit/typed/scaladsl/TestProbeSpec.scala
View file

@ -171,8 +171,8 @@ class TestProbeSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
object TestProbeSpec {
val timeoutConfig = ConfigFactory.parseString("""
akka.actor.testkit.typed.default-timeout = 100ms
akka.test.default-timeout = 100ms""")
pekko.actor.testkit.typed.default-timeout = 100ms
pekko.test.default-timeout = 100ms""")
/** Helper events for tests. */
final case class EventT(id: Long)

2
akka-actor-tests/src/test/java/org/apache/pekko/actor/JavaExtension.java
View file

@ -66,7 +66,7 @@ public class JavaExtension extends JUnitSuite {
new AkkaJUnitActorSystemResource(
"JavaExtension",
ConfigFactory.parseString(
"akka.extensions = [ \"org.apache.pekko.actor.JavaExtension$TestExtensionId\" ]")
"pekko.extensions = [ \"org.apache.pekko.actor.JavaExtension$TestExtensionId\" ]")
.withFallback(AkkaSpec.testConf()));
private final ActorSystem system = actorSystemResource.getSystem();

2
akka-actor-tests/src/test/java/org/apache/pekko/actor/StashJavaAPI.java
View file

@ -42,6 +42,6 @@ public class StashJavaAPI extends JUnitSuite {
public void mustBeAbleToUseUnrestrictedStash() {
testAStashApi(
Props.create(StashJavaAPITestActors.WithUnrestrictedStash.class)
.withMailbox("akka.actor.mailbox.unbounded-deque-based"));
.withMailbox("pekko.actor.mailbox.unbounded-deque-based"));
}
}

2
akka-actor-tests/src/test/java/org/apache/pekko/event/LoggingAdapterTest.java
View file

@ -30,7 +30,7 @@ import static org.junit.Assert.assertTrue;
public class LoggingAdapterTest extends JUnitSuite {
private static final Config config = ConfigFactory.parseString("akka.loglevel = DEBUG\n");
private static final Config config = ConfigFactory.parseString("pekko.loglevel = DEBUG\n");
@Rule
public AkkaJUnitActorSystemResource actorSystemResource =

4
akka-actor-tests/src/test/resources/reference.conf
View file

@ -1,8 +1,8 @@
akka {
pekko {
# for the org.apache.pekko.actor.ExtensionSpec
library-extensions += "org.apache.pekko.actor.InstanceCountingExtension"
}
# FIXME Some test depend on this setting when running on windows.
# It should be removed when #17122 is solved.
akka.io.tcp.windows-connection-abort-workaround-enabled = auto
pekko.io.tcp.windows-connection-abort-workaround-enabled = auto

28
akka-actor-tests/src/test/scala/org/apache/pekko/actor/ActorMailboxSpec.scala
View file

@ -84,7 +84,7 @@ object ActorMailboxSpec {
mailbox-type = "org.apache.pekko.actor.ActorMailboxSpec$$MCBoundedMailbox"
}
akka.actor.deployment {
pekko.actor.deployment {
/default-default {
}
/default-override-from-props {
@ -110,10 +110,10 @@ object ActorMailboxSpec {
mailbox = bounded-mailbox-with-zero-pushtimeout
}
/default-unbounded-deque {
mailbox = akka.actor.mailbox.unbounded-deque-based
mailbox = pekko.actor.mailbox.unbounded-deque-based
}
/default-unbounded-deque-override-trait {
mailbox = akka.actor.mailbox.unbounded-deque-based
mailbox = pekko.actor.mailbox.unbounded-deque-based
}
/unbounded-default {
dispatcher = unbounded-dispatcher
@ -138,20 +138,20 @@ object ActorMailboxSpec {
}
/bounded-deque-requirements-configured {
dispatcher = requiring-bounded-dispatcher
mailbox = akka.actor.mailbox.bounded-deque-based
mailbox = pekko.actor.mailbox.bounded-deque-based
}
/bounded-deque-require-unbounded-configured {
dispatcher = requiring-bounded-dispatcher
mailbox = akka.actor.mailbox.unbounded-deque-based
mailbox = pekko.actor.mailbox.unbounded-deque-based
}
/bounded-deque-require-unbounded-unconfigured {
dispatcher = requiring-bounded-dispatcher
}
/bounded-deque-requirements-configured-props-disp {
mailbox = akka.actor.mailbox.bounded-deque-based
mailbox = pekko.actor.mailbox.bounded-deque-based
}
/bounded-deque-require-unbounded-configured-props-disp {
mailbox = akka.actor.mailbox.unbounded-deque-based
mailbox = pekko.actor.mailbox.unbounded-deque-based
}
/bounded-deque-requirements-configured-props-mail {
dispatcher = requiring-bounded-dispatcher
@ -164,7 +164,7 @@ object ActorMailboxSpec {
}
}
akka.actor.mailbox.requirements {
pekko.actor.mailbox.requirements {
"org.apache.pekko.actor.ActorMailboxSpec$$MCBoundedMessageQueueSemantics" =
mc-bounded-mailbox
}
@ -249,7 +249,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
"get an unbounded deque message queue when it is only configured on the props" in {
checkMailboxQueue(
Props[QueueReportingActor]().withMailbox("akka.actor.mailbox.unbounded-deque-based"),
Props[QueueReportingActor]().withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"default-override-from-props",
UnboundedDeqMailboxTypes)
}
@ -340,7 +340,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
"get an unbounded message queue overriding configuration on the props" in {
checkMailboxQueue(
Props[QueueReportingActor]().withMailbox("akka.actor.mailbox.unbounded-deque-based"),
Props[QueueReportingActor]().withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"bounded-unbounded-override-props",
UnboundedMailboxTypes)
}
@ -366,7 +366,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
checkMailboxQueue(
Props[StashQueueReportingActor]()
.withDispatcher("requiring-bounded-dispatcher")
.withMailbox("akka.actor.mailbox.bounded-deque-based"),
.withMailbox("pekko.actor.mailbox.bounded-deque-based"),
"bounded-deque-requirements-configured-props",
BoundedDeqMailboxTypes)
}
@ -376,7 +376,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
system.actorOf(
Props[StashQueueReportingActor]()
.withDispatcher("requiring-bounded-dispatcher")
.withMailbox("akka.actor.mailbox.unbounded-deque-based"),
.withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"bounded-deque-require-unbounded-configured-props"))
}
@ -410,7 +410,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
"get a bounded deque-based message queue if configured and required with Props (mailbox)" in {
checkMailboxQueue(
Props[StashQueueReportingActor]().withMailbox("akka.actor.mailbox.bounded-deque-based"),
Props[StashQueueReportingActor]().withMailbox("pekko.actor.mailbox.bounded-deque-based"),
"bounded-deque-requirements-configured-props-mail",
BoundedDeqMailboxTypes)
}
@ -418,7 +418,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
"fail with a unbounded deque-based message queue if configured and required with Props (mailbox)" in {
intercept[ConfigurationException](
system.actorOf(
Props[StashQueueReportingActor]().withMailbox("akka.actor.mailbox.unbounded-deque-based"),
Props[StashQueueReportingActor]().withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"bounded-deque-require-unbounded-configured-props-mail"))
}

2
akka-actor-tests/src/test/scala/org/apache/pekko/actor/ActorRefSpec.scala
View file

@ -114,7 +114,7 @@ object ActorRefSpec {
class ActorRefSpec extends AkkaSpec("""
# testing Java serialization of ActorRef
akka.actor.allow-java-serialization = on
pekko.actor.allow-java-serialization = on
""") with DefaultTimeout {
import org.apache.pekko.actor.ActorRefSpec._

12
akka-actor-tests/src/test/scala/org/apache/pekko/actor/ActorSystemDispatcherSpec.scala
View file

@ -69,7 +69,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
val ecProbe = TestProbe()
val ec = new SnitchingExecutionContext(ecProbe.ref, ExecutionContexts.global())
val config = ConfigFactory.parseString("akka.actor.default-dispatcher.executor = \"fork-join-executor\"")
val config = ConfigFactory.parseString("pekko.actor.default-dispatcher.executor = \"fork-join-executor\"")
val system2 = ActorSystem(
name = "ActorSystemDispatchersSpec-ec-configured",
config = Some(config),
@ -97,13 +97,13 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
val sys = ActorSystem(
"ActorSystemDispatchersSpec-override-internal-disp",
ConfigFactory.parseString("""
akka.actor.internal-dispatcher = akka.actor.default-dispatcher
pekko.actor.internal-dispatcher = pekko.actor.default-dispatcher
"""))
try {
// that the user guardian runs on the overridden dispatcher instead of internal
// isn't really a guarantee any internal actor has been made running on the right one
// but it's better than no test coverage at all
userGuardianDispatcher(sys) should ===("akka.actor.default-dispatcher")
userGuardianDispatcher(sys) should ===("pekko.actor.default-dispatcher")
} finally {
shutdown(sys)
}
@ -118,7 +118,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
ActorSystem(
name = "ActorSystemDispatchersSpec-passed-in-ec-for-internal",
config = Some(ConfigFactory.parseString("""
akka.actor.internal-dispatcher = akka.actor.default-dispatcher
pekko.actor.internal-dispatcher = pekko.actor.default-dispatcher
""")),
defaultExecutionContext = Some(ec))
@ -141,7 +141,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
}
"use an internal dispatcher for the guardian by default" in {
userGuardianDispatcher(system) should ===("akka.actor.internal-dispatcher")
userGuardianDispatcher(system) should ===("pekko.actor.internal-dispatcher")
}
"use the default dispatcher by a user provided user guardian" in {
@ -154,7 +154,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
ActorSystemSetup.empty)
sys.start()
try {
userGuardianDispatcher(sys) should ===("akka.actor.default-dispatcher")
userGuardianDispatcher(sys) should ===("pekko.actor.default-dispatcher")
} finally shutdown(sys)
}

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/ActorSystemSpec.scala
View file

@ -142,7 +142,7 @@ class ActorSystemSpec extends AkkaSpec(ActorSystemSpec.config) with ImplicitSend
"log dead letters" in {
val sys =
ActorSystem("LogDeadLetters", ConfigFactory.parseString("akka.loglevel=INFO").withFallback(AkkaSpec.testConf))
ActorSystem("LogDeadLetters", ConfigFactory.parseString("pekko.loglevel=INFO").withFallback(AkkaSpec.testConf))
try {
val probe = TestProbe()(sys)
val a = sys.actorOf(Props[ActorSystemSpec.Terminater]())
@ -166,7 +166,7 @@ class ActorSystemSpec extends AkkaSpec(ActorSystemSpec.config) with ImplicitSend
"log dead letters sent without sender reference" in {
val sys =
ActorSystem("LogDeadLetters", ConfigFactory.parseString("akka.loglevel=INFO").withFallback(AkkaSpec.testConf))
ActorSystem("LogDeadLetters", ConfigFactory.parseString("pekko.loglevel=INFO").withFallback(AkkaSpec.testConf))
try {
val probe = TestProbe()(sys)
val a = sys.actorOf(Props[ActorSystemSpec.Terminater]())
@ -317,7 +317,7 @@ class ActorSystemSpec extends AkkaSpec(ActorSystemSpec.config) with ImplicitSend
ActorSystem(
"Stop",
ConfigFactory
.parseString("akka.actor.guardian-supervisor-strategy=org.apache.pekko.actor.StoppingSupervisorStrategy")
.parseString("pekko.actor.guardian-supervisor-strategy=org.apache.pekko.actor.StoppingSupervisorStrategy")
.withFallback(AkkaSpec.testConf))
val a = system.actorOf(Props(new Actor {
def receive = {
@ -340,7 +340,7 @@ class ActorSystemSpec extends AkkaSpec(ActorSystemSpec.config) with ImplicitSend
ActorSystem(
"Stop",
ConfigFactory
.parseString("akka.actor.guardian-supervisor-strategy=\"org.apache.pekko.actor.ActorSystemSpec$Strategy\"")
.parseString("pekko.actor.guardian-supervisor-strategy=\"org.apache.pekko.actor.ActorSystemSpec$Strategy\"")
.withFallback(AkkaSpec.testConf))
val a = system.actorOf(Props(new Actor {
def receive = {

2
akka-actor-tests/src/test/scala/org/apache/pekko/actor/Bench.scala
View file

@ -109,7 +109,7 @@ object Chameneos {
}
def run(): Unit = {
// System.setProperty("akka.config", "akka.conf")
// System.setProperty("pekko.config", "pekko.conf")
Chameneos.start = System.currentTimeMillis
val system = ActorSystem()
system.actorOf(Props(new Mall(1000000, 4)))

42
akka-actor-tests/src/test/scala/org/apache/pekko/actor/CoordinatedShutdownSpec.scala
View file

@ -27,8 +27,8 @@ import scala.concurrent.Promise
class CoordinatedShutdownSpec
extends AkkaSpec(ConfigFactory.parseString("""
akka.loglevel=INFO
akka.loggers = ["org.apache.pekko.testkit.TestEventListener"]
pekko.loglevel=INFO
pekko.loggers = ["org.apache.pekko.testkit.TestEventListener"]
""")) {
def extSys = system.asInstanceOf[ExtendedActorSystem]
@ -511,13 +511,13 @@ class CoordinatedShutdownSpec
}
"default exit code to 0" in {
lazy val conf = ConfigFactory.load().getConfig("akka.coordinated-shutdown")
lazy val conf = ConfigFactory.load().getConfig("pekko.coordinated-shutdown")
val confWithOverrides = CoordinatedShutdown.confWithOverrides(conf, None)
confWithOverrides.getInt("exit-code") should ===(0)
}
"default exit code to -1 when the Reason is ClusterDowning" in {
lazy val conf = ConfigFactory.load().getConfig("akka.coordinated-shutdown")
lazy val conf = ConfigFactory.load().getConfig("pekko.coordinated-shutdown")
val confWithOverrides =
CoordinatedShutdown.confWithOverrides(conf, Some(CoordinatedShutdown.ClusterDowningReason))
confWithOverrides.getInt("exit-code") should ===(-1)
@ -549,7 +549,7 @@ class CoordinatedShutdownSpec
val sys = ActorSystem(
system.name,
ConfigFactory
.parseString("akka.coordinated-shutdown.run-by-actor-system-terminate = off")
.parseString("pekko.coordinated-shutdown.run-by-actor-system-terminate = off")
.withFallback(system.settings.config))
try {
Await.result(sys.terminate(), 10.seconds)
@ -565,7 +565,7 @@ class CoordinatedShutdownSpec
val sys = ActorSystem(
system.name,
ConfigFactory
.parseString("akka.coordinated-shutdown.terminate-actor-system = off")
.parseString("pekko.coordinated-shutdown.terminate-actor-system = off")
.withFallback(system.settings.config))
// will only get here if test is failing
shutdown(sys)
@ -575,9 +575,9 @@ class CoordinatedShutdownSpec
"add and remove user JVM hooks with run-by-jvm-shutdown-hook = off, terminate-actor-system = off" in new JvmHookTest {
lazy val systemName = s"CoordinatedShutdownSpec-JvmHooks-1-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = off
akka.coordinated-shutdown.terminate-actor-system = off
akka.coordinated-shutdown.run-by-actor-system-terminate = off
pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = off
pekko.coordinated-shutdown.terminate-actor-system = off
pekko.coordinated-shutdown.run-by-actor-system-terminate = off
""")
override def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -591,9 +591,9 @@ class CoordinatedShutdownSpec
"add and remove user JVM hooks with run-by-jvm-shutdown-hook = on, terminate-actor-system = off" in new JvmHookTest {
lazy val systemName = s"CoordinatedShutdownSpec-JvmHooks-2-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on
akka.coordinated-shutdown.terminate-actor-system = off
akka.coordinated-shutdown.run-by-actor-system-terminate = off
pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
pekko.coordinated-shutdown.terminate-actor-system = off
pekko.coordinated-shutdown.run-by-actor-system-terminate = off
""")
override def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -608,8 +608,8 @@ class CoordinatedShutdownSpec
"add and remove user JVM hooks with run-by-jvm-shutdown-hook = on, terminate-actor-system = on" in new JvmHookTest {
lazy val systemName = s"CoordinatedShutdownSpec-JvmHooks-3-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on
akka.coordinated-shutdown.terminate-actor-system = on
pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
pekko.coordinated-shutdown.terminate-actor-system = on
""")
def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -620,11 +620,11 @@ class CoordinatedShutdownSpec
}
}
"add and remove user JVM hooks with run-by-jvm-shutdown-hook = on, akka.jvm-shutdown-hooks = off" in new JvmHookTest {
"add and remove user JVM hooks with run-by-jvm-shutdown-hook = on, pekko.jvm-shutdown-hooks = off" in new JvmHookTest {
lazy val systemName = s"CoordinatedShutdownSpec-JvmHooks-4-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString("""
akka.jvm-shutdown-hooks = off
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on
pekko.jvm-shutdown-hooks = off
pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
""")
def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -638,8 +638,8 @@ class CoordinatedShutdownSpec
"access extension after system termination" in new JvmHookTest {
lazy val systemName = s"CoordinatedShutdownSpec-terminated-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on
akka.coordinated-shutdown.terminate-actor-system = on
pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
pekko.coordinated-shutdown.terminate-actor-system = on
""")
def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -653,7 +653,7 @@ class CoordinatedShutdownSpec
val system = ActorSystem(
s"CoordinatedShutdownSpec-terminated-${System.currentTimeMillis()}",
ConfigFactory.parseString("""
akka.coordinated-shutdown.phases {
pekko.coordinated-shutdown.phases {
before-actor-system-terminate {
}
@ -780,7 +780,7 @@ class CoordinatedShutdownSpec
} else false
}
}
private val csConfig = newSystem.settings.config.getConfig("akka.coordinated-shutdown")
private val csConfig = newSystem.settings.config.getConfig("pekko.coordinated-shutdown")
// pretend extension creation and start
private val cs = new CoordinatedShutdown(newSystem, CoordinatedShutdown.phasesFromConfig(csConfig), mockRuntime)
CoordinatedShutdown.init(newSystem, csConfig, cs)

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/DeadLetterSuspensionSpec.scala
View file

@ -35,9 +35,9 @@ object DeadLetterSuspensionSpec {
}
class DeadLetterSuspensionSpec extends AkkaSpec("""
akka.loglevel = INFO
akka.log-dead-letters = 4
akka.log-dead-letters-suspend-duration = 2s
pekko.loglevel = INFO
pekko.log-dead-letters = 4
pekko.log-dead-letters-suspend-duration = 2s
""") with ImplicitSender {
import DeadLetterSuspensionSpec._
@ -58,7 +58,7 @@ class DeadLetterSuspensionSpec extends AkkaSpec("""
private def expectedUnhandledLogMessage(count: Int): String =
s"Message [java.lang.Integer] from $testActor to $unhandledActor was unhandled. [$count] dead letters encountered"
"must suspend dead-letters logging when reaching 'akka.log-dead-letters', and then re-enable" in {
"must suspend dead-letters logging when reaching 'pekko.log-dead-letters', and then re-enable" in {
EventFilter.info(start = expectedDeadLettersLogMessage(1), occurrences = 1).intercept {
deadActor ! 1
}

24
akka-actor-tests/src/test/scala/org/apache/pekko/actor/DeployerSpec.scala
View file

@ -17,7 +17,7 @@ import pekko.testkit.AkkaSpec
object DeployerSpec {
val deployerConf = ConfigFactory.parseString(
"""
akka.actor.deployment {
pekko.actor.deployment {
/service1 {
}
/service-direct {
@ -82,7 +82,7 @@ object DeployerSpec {
class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
"A Deployer" must {
"be able to parse 'akka.actor.deployment._' with all default values" in {
"be able to parse 'pekko.actor.deployment._' with all default values" in {
val service = "/service1"
val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
@ -103,7 +103,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
deployment should ===(None)
}
"be able to parse 'akka.actor.deployment._' with dispatcher config" in {
"be able to parse 'pekko.actor.deployment._' with dispatcher config" in {
val service = "/service3"
val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
@ -118,7 +118,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
Deploy.NoMailboxGiven)))
}
"be able to parse 'akka.actor.deployment._' with mailbox config" in {
"be able to parse 'pekko.actor.deployment._' with mailbox config" in {
val service = "/service4"
val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
@ -138,7 +138,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
val invalidDeployerConf = ConfigFactory
.parseString(
"""
akka.actor.deployment {
pekko.actor.deployment {
/service-invalid-number-of-instances {
router = round-robin-pool
nr-of-instances = boom
@ -157,7 +157,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
val invalidDeployerConf = ConfigFactory
.parseString(
"""
akka.actor.deployment {
pekko.actor.deployment {
/gul/ubåt {
router = round-robin-pool
nr-of-instances = 2
@ -173,7 +173,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
e.getMessage should include("[/gul/ubåt]")
}
"be able to parse 'akka.actor.deployment._' with from-code router" in {
"be able to parse 'pekko.actor.deployment._' with from-code router" in {
assertRouting("/service-direct", NoRouter, "/service-direct")
}
@ -181,26 +181,26 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
assertRouting("/service-direct2", NoRouter, "/service-direct2")
}
"be able to parse 'akka.actor.deployment._' with round-robin router" in {
"be able to parse 'pekko.actor.deployment._' with round-robin router" in {
assertRouting("/service-round-robin", RoundRobinPool(1), "/service-round-robin")
}
"be able to parse 'akka.actor.deployment._' with random router" in {
"be able to parse 'pekko.actor.deployment._' with random router" in {
assertRouting("/service-random", RandomPool(1), "/service-random")
}
"be able to parse 'akka.actor.deployment._' with scatter-gather router" in {
"be able to parse 'pekko.actor.deployment._' with scatter-gather router" in {
assertRouting(
"/service-scatter-gather",
ScatterGatherFirstCompletedPool(nrOfInstances = 1, within = 2 seconds),
"/service-scatter-gather")
}
"be able to parse 'akka.actor.deployment._' with consistent-hashing router" in {
"be able to parse 'pekko.actor.deployment._' with consistent-hashing router" in {
assertRouting("/service-consistent-hashing", ConsistentHashingPool(1), "/service-consistent-hashing")
}
"be able to parse 'akka.actor.deployment._' with router resizer" in {
"be able to parse 'pekko.actor.deployment._' with router resizer" in {
val resizer = DefaultResizer()
assertRouting("/service-resizer", RoundRobinPool(nrOfInstances = 0, resizer = Some(resizer)), "/service-resizer")
}

20
akka-actor-tests/src/test/scala/org/apache/pekko/actor/ExtensionSpec.scala
View file

@ -59,7 +59,7 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
"The ActorSystem extensions support" should {
"support extensions" in {
val config = ConfigFactory.parseString("""akka.extensions = ["org.apache.pekko.actor.TestExtension"]""")
val config = ConfigFactory.parseString("""pekko.extensions = ["org.apache.pekko.actor.TestExtension"]""")
val system = ActorSystem("extensions", config)
// TestExtension is configured and should be loaded at startup
@ -87,23 +87,23 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
shutdownActorSystem(system)
}
"fail the actor system if an extension listed in akka.extensions fails to start" in {
"fail the actor system if an extension listed in pekko.extensions fails to start" in {
intercept[RuntimeException] {
val system = ActorSystem(
"failing",
ConfigFactory.parseString("""
akka.extensions = ["org.apache.pekko.actor.FailingTestExtension"]
pekko.extensions = ["org.apache.pekko.actor.FailingTestExtension"]
"""))
shutdownActorSystem(system)
}
}
"log an error if an extension listed in akka.extensions cannot be loaded" in {
"log an error if an extension listed in pekko.extensions cannot be loaded" in {
val system = ActorSystem(
"failing",
ConfigFactory.parseString("""
akka.extensions = ["org.apache.pekko.actor.MissingExtension"]
pekko.extensions = ["org.apache.pekko.actor.MissingExtension"]
"""))
EventFilter.error(
"While trying to load extension [org.apache.pekko.actor.MissingExtension], skipping.").intercept(())(system)
@ -115,7 +115,7 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
// could be initialized by other tests, but assuming tests are not running in parallel
val countBefore = InstanceCountingExtension.createCount.get()
val system = ActorSystem("extensions")
val listedExtensions = system.settings.config.getStringList("akka.library-extensions").asScala
val listedExtensions = system.settings.config.getStringList("pekko.library-extensions").asScala
listedExtensions.count(_.contains("InstanceCountingExtension")) should ===(1)
InstanceCountingExtension.createCount.get() - countBefore should ===(1)
@ -131,9 +131,9 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
"extensions",
ConfigFactory.parseString(
"""
akka.library-extensions = ["org.apache.pekko.actor.InstanceCountingExtension", "org.apache.pekko.actor.InstanceCountingExtension", "org.apache.pekko.actor.InstanceCountingExtension$"]
pekko.library-extensions = ["org.apache.pekko.actor.InstanceCountingExtension", "org.apache.pekko.actor.InstanceCountingExtension", "org.apache.pekko.actor.InstanceCountingExtension$"]
"""))
val listedExtensions = system.settings.config.getStringList("akka.library-extensions").asScala
val listedExtensions = system.settings.config.getStringList("pekko.library-extensions").asScala
listedExtensions.count(_.contains("InstanceCountingExtension")) should ===(3) // testing duplicate names
InstanceCountingExtension.createCount.get() - countBefore should ===(1)
@ -146,7 +146,7 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
ActorSystem(
"failing",
ConfigFactory.parseString("""
akka.library-extensions += "org.apache.pekko.actor.FailingTestExtension"
pekko.library-extensions += "org.apache.pekko.actor.FailingTestExtension"
""").withFallback(ConfigFactory.load()).resolve())
}
@ -157,7 +157,7 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
ActorSystem(
"failing",
ConfigFactory.parseString("""
akka.library-extensions += "org.apache.pekko.actor.MissingExtension"
pekko.library-extensions += "org.apache.pekko.actor.MissingExtension"
""").withFallback(ConfigFactory.load()))
}
}

4
akka-actor-tests/src/test/scala/org/apache/pekko/actor/FSMActorSpec.scala
View file

@ -101,7 +101,7 @@ object FSMActorSpec {
final case class CodeState(soFar: String, code: String)
}
class FSMActorSpec extends AkkaSpec(Map("akka.actor.debug.fsm" -> true)) with ImplicitSender {
class FSMActorSpec extends AkkaSpec(Map("pekko.actor.debug.fsm" -> true)) with ImplicitSender {
import FSMActorSpec._
val timeout = Timeout(2 seconds)
@ -254,7 +254,7 @@ class FSMActorSpec extends AkkaSpec(Map("akka.actor.debug.fsm" -> true)) with Im
"log events and transitions if asked to do so" in {
import pekko.util.ccompat.JavaConverters._
val config = ConfigFactory
.parseMap(Map("akka.loglevel" -> "DEBUG", "akka.actor.debug.fsm" -> true).asJava)
.parseMap(Map("pekko.loglevel" -> "DEBUG", "pekko.actor.debug.fsm" -> true).asJava)
.withFallback(system.settings.config)
val fsmEventSystem = ActorSystem("fsmEvent", config)
try {

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/FunctionRefSpec.scala
View file

@ -39,10 +39,10 @@ object FunctionRefSpec {
class FunctionRefSpec extends AkkaSpec("""
# test is using Java serialization and relies on serialize-messages=on
akka.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = off
akka.actor.serialize-messages = on
akka.actor.no-serialization-verification-needed-class-prefix = []
pekko.actor.allow-java-serialization = on
pekko.actor.warn-about-java-serializer-usage = off
pekko.actor.serialize-messages = on
pekko.actor.no-serialization-verification-needed-class-prefix = []
""") with ImplicitSender {
import FunctionRefSpec._

2
akka-actor-tests/src/test/scala/org/apache/pekko/actor/LocalActorRefProviderSpec.scala
View file

@ -19,7 +19,7 @@ import pekko.util.Timeout
object LocalActorRefProviderSpec {
val config = """
akka {
pekko {
log-dead-letters = on
actor {
debug.unhandled = on

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/PropsCreationSpec.scala
View file

@ -32,10 +32,10 @@ object PropsCreationSpec {
class PropsCreationSpec extends AkkaSpec("""
# test is using Java serialization and relies on serialize-creators=on
akka.actor.serialize-creators = on
akka.actor.no-serialization-verification-needed-class-prefix = []
akka.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = off
pekko.actor.serialize-creators = on
pekko.actor.no-serialization-verification-needed-class-prefix = []
pekko.actor.allow-java-serialization = on
pekko.actor.warn-about-java-serializer-usage = off
""") {
import org.apache.pekko.actor.PropsCreationSpec._

2
akka-actor-tests/src/test/scala/org/apache/pekko/actor/ProviderSelectionSpec.scala
View file

@ -22,7 +22,7 @@ class ProviderSelectionSpec extends AbstractSpec {
val classLoader = findClassLoader()
def settingsWith(key: String): Settings = {
val c = ConfigFactory.parseString(s"""akka.actor.provider = "$key"""").withFallback(localConfig)
val c = ConfigFactory.parseString(s"""pekko.actor.provider = "$key"""").withFallback(localConfig)
new Settings(classLoader, c, "test", setup)
}

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/SchedulerSpec.scala
View file

@ -27,8 +27,8 @@ import pekko.testkit._
object SchedulerSpec {
val testConfRevolver =
ConfigFactory.parseString("""
akka.scheduler.implementation = org.apache.pekko.actor.LightArrayRevolverScheduler
akka.scheduler.ticks-per-wheel = 32
pekko.scheduler.implementation = org.apache.pekko.actor.LightArrayRevolverScheduler
pekko.scheduler.ticks-per-wheel = 32
""").withFallback(AkkaSpec.testConf)
}
@ -473,7 +473,7 @@ class LightArrayRevolverSchedulerSpec extends AkkaSpec(SchedulerSpec.testConfRev
}
"survive vicious enqueueing" taggedAs TimingTest in {
withScheduler(config = ConfigFactory.parseString("akka.scheduler.ticks-per-wheel=2")) { (sched, driver) =>
withScheduler(config = ConfigFactory.parseString("pekko.scheduler.ticks-per-wheel=2")) { (sched, driver) =>
import driver._
import system.dispatcher
val counter = new AtomicInteger
@ -533,7 +533,7 @@ class LightArrayRevolverSchedulerSpec extends AkkaSpec(SchedulerSpec.testConfRev
}
"correctly wrap around wheel rounds" taggedAs TimingTest in {
withScheduler(config = ConfigFactory.parseString("akka.scheduler.ticks-per-wheel=2")) { (sched, driver) =>
withScheduler(config = ConfigFactory.parseString("pekko.scheduler.ticks-per-wheel=2")) { (sched, driver) =>
implicit def ec: ExecutionContext = localEC
import driver._
val start = step / 2

4
akka-actor-tests/src/test/scala/org/apache/pekko/actor/SupervisorHierarchySpec.scala
View file

@ -85,8 +85,8 @@ object SupervisorHierarchySpec {
hierarchy {
type = "org.apache.pekko.actor.SupervisorHierarchySpec$MyDispatcherConfigurator"
}
akka.loglevel = INFO
akka.actor.debug.fsm = on
pekko.loglevel = INFO
pekko.actor.debug.fsm = on
""")
class MyDispatcherConfigurator(config: Config, prerequisites: DispatcherPrerequisites)

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/TypedActorSpec.scala
View file

@ -36,11 +36,11 @@ object TypedActorSpec {
fixed-pool-size = 60
}
}
akka.actor.serializers.sample = "org.apache.pekko.actor.TypedActorSpec$SampleSerializerWithStringManifest$"
akka.actor.serialization-bindings."org.apache.pekko.actor.TypedActorSpec$WithStringSerializedClass" = sample
pekko.actor.serializers.sample = "org.apache.pekko.actor.TypedActorSpec$SampleSerializerWithStringManifest$"
pekko.actor.serialization-bindings."org.apache.pekko.actor.TypedActorSpec$WithStringSerializedClass" = sample
# test is using Java serialization and not priority to convert
akka.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = off
pekko.actor.allow-java-serialization = on
pekko.actor.warn-about-java-serializer-usage = off
"""
class CyclicIterator[T](val items: immutable.Seq[T]) extends Iterator[T] {

8
akka-actor-tests/src/test/scala/org/apache/pekko/actor/dispatch/DispatchersSpec.scala
View file

@ -42,7 +42,7 @@ object DispatchersSpec {
my-aliased-dispatcher = myapp.mydispatcher
missing-aliased-dispatcher = myapp.missing-dispatcher
}
akka.actor.deployment {
pekko.actor.deployment {
/echo1 {
dispatcher = myapp.mydispatcher
}
@ -123,7 +123,7 @@ class DispatchersSpec extends AkkaSpec(DispatchersSpec.config) with ImplicitSend
def validTypes = typesAndValidators.keys.toList
val defaultDispatcherConfig = settings.config.getConfig("akka.actor.default-dispatcher")
val defaultDispatcherConfig = settings.config.getConfig("pekko.actor.default-dispatcher")
lazy val allDispatchers: Map[String, MessageDispatcher] = {
import pekko.util.ccompat.JavaConverters._
@ -232,7 +232,7 @@ class DispatchersSpec extends AkkaSpec(DispatchersSpec.config) with ImplicitSend
"include system name and dispatcher id in thread names for default-dispatcher" in {
system.actorOf(Props[ThreadNameEcho]()) ! "what's the name?"
val Expected = R("(DispatchersSpec-akka.actor.default-dispatcher-[1-9][0-9]*)")
val Expected = R("(DispatchersSpec-pekko.actor.default-dispatcher-[1-9][0-9]*)")
expectMsgPF() {
case Expected(_) =>
}
@ -268,7 +268,7 @@ class DispatchersSpec extends AkkaSpec(DispatchersSpec.config) with ImplicitSend
pool ! Identify(None)
val routee = expectMsgType[ActorIdentity].ref.get
routee ! "what's the name?"
val Expected = R("""(DispatchersSpec-akka\.actor\.deployment\./pool1\.pool-dispatcher-[1-9][0-9]*)""")
val Expected = R("""(DispatchersSpec-pekko\.actor\.deployment\./pool1\.pool-dispatcher-[1-9][0-9]*)""")
expectMsgPF() {
case Expected(_) =>
}

6
akka-actor-tests/src/test/scala/org/apache/pekko/actor/dungeon/DispatchSpec.scala
View file

@ -18,13 +18,13 @@ object DispatchSpec {
}
}
class DispatchSpec extends AkkaSpec("""
akka.actor.serialize-messages = on
akka.actor.no-serialization-verification-needed-class-prefix = []
pekko.actor.serialize-messages = on
pekko.actor.no-serialization-verification-needed-class-prefix = []
""") with DefaultTimeout {
import DispatchSpec._
"The dispatcher" should {
"log an appropriate message when akka.actor.serialize-messages triggers a serialization error" in {
"log an appropriate message when pekko.actor.serialize-messages triggers a serialization error" in {
val actor = system.actorOf(Props[EmptyActor]())
EventFilter[Exception](pattern = ".*NoSerializationVerificationNeeded.*", occurrences = 1).intercept {
actor ! new UnserializableMessageClass

60
akka-actor-tests/src/test/scala/org/apache/pekko/config/ConfigSpec.scala
View file

@ -29,66 +29,66 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
{
import config._
getString("akka.version") should ===(ActorSystem.Version)
getString("pekko.version") should ===(ActorSystem.Version)
settings.ConfigVersion should ===(ActorSystem.Version)
getBoolean("akka.daemonic") should ===(false)
getBoolean("pekko.daemonic") should ===(false)
getBoolean("akka.actor.serialize-messages") should ===(false)
getBoolean("pekko.actor.serialize-messages") should ===(false)
settings.SerializeAllMessages should ===(false)
settings.NoSerializationVerificationNeededClassPrefix should ===(Set("org.apache.pekko."))
getInt("akka.scheduler.ticks-per-wheel") should ===(512)
getDuration("akka.scheduler.tick-duration", TimeUnit.MILLISECONDS) should ===(10L)
getString("akka.scheduler.implementation") should ===("org.apache.pekko.actor.LightArrayRevolverScheduler")
getInt("pekko.scheduler.ticks-per-wheel") should ===(512)
getDuration("pekko.scheduler.tick-duration", TimeUnit.MILLISECONDS) should ===(10L)
getString("pekko.scheduler.implementation") should ===("org.apache.pekko.actor.LightArrayRevolverScheduler")
getBoolean("akka.daemonic") should ===(false)
getBoolean("pekko.daemonic") should ===(false)
settings.Daemonicity should ===(false)
getBoolean("akka.jvm-exit-on-fatal-error") should ===(true)
getBoolean("pekko.jvm-exit-on-fatal-error") should ===(true)
settings.JvmExitOnFatalError should ===(true)
settings.JvmShutdownHooks should ===(true)
getBoolean("akka.fail-mixed-versions") should ===(true)
getBoolean("pekko.fail-mixed-versions") should ===(true)
settings.FailMixedVersions should ===(true)
getInt("akka.actor.deployment.default.virtual-nodes-factor") should ===(10)
getInt("pekko.actor.deployment.default.virtual-nodes-factor") should ===(10)
settings.DefaultVirtualNodesFactor should ===(10)
getDuration("akka.actor.unstarted-push-timeout", TimeUnit.MILLISECONDS) should ===(10.seconds.toMillis)
getDuration("pekko.actor.unstarted-push-timeout", TimeUnit.MILLISECONDS) should ===(10.seconds.toMillis)
settings.UnstartedPushTimeout.duration should ===(10.seconds)
settings.Loggers.size should ===(1)
settings.Loggers.head should ===(classOf[DefaultLogger].getName)
getStringList("akka.loggers").get(0) should ===(classOf[DefaultLogger].getName)
getStringList("pekko.loggers").get(0) should ===(classOf[DefaultLogger].getName)
getDuration("akka.logger-startup-timeout", TimeUnit.MILLISECONDS) should ===(5.seconds.toMillis)
getDuration("pekko.logger-startup-timeout", TimeUnit.MILLISECONDS) should ===(5.seconds.toMillis)
settings.LoggerStartTimeout.duration should ===(5.seconds)
getString("akka.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
getString("pekko.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
getInt("akka.log-dead-letters") should ===(10)
getInt("pekko.log-dead-letters") should ===(10)
settings.LogDeadLetters should ===(10)
getBoolean("akka.log-dead-letters-during-shutdown") should ===(false)
getBoolean("pekko.log-dead-letters-during-shutdown") should ===(false)
settings.LogDeadLettersDuringShutdown should ===(false)
getDuration("akka.log-dead-letters-suspend-duration", TimeUnit.MILLISECONDS) should ===(5 * 60 * 1000L)
getDuration("pekko.log-dead-letters-suspend-duration", TimeUnit.MILLISECONDS) should ===(5 * 60 * 1000L)
settings.LogDeadLettersSuspendDuration should ===(5.minutes)
getBoolean("akka.coordinated-shutdown.terminate-actor-system") should ===(true)
getBoolean("pekko.coordinated-shutdown.terminate-actor-system") should ===(true)
settings.CoordinatedShutdownTerminateActorSystem should ===(true)
getBoolean("akka.coordinated-shutdown.run-by-actor-system-terminate") should ===(true)
getBoolean("pekko.coordinated-shutdown.run-by-actor-system-terminate") should ===(true)
settings.CoordinatedShutdownRunByActorSystemTerminate should ===(true)
getBoolean("akka.actor.allow-java-serialization") should ===(false)
getBoolean("pekko.actor.allow-java-serialization") should ===(false)
settings.AllowJavaSerialization should ===(false)
}
{
val c = config.getConfig("akka.actor.default-dispatcher")
val c = config.getConfig("pekko.actor.default-dispatcher")
// General dispatcher config
@ -133,7 +133,7 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
// Debug config
{
val debug = config.getConfig("akka.actor.debug")
val debug = config.getConfig("pekko.actor.debug")
import debug._
getBoolean("receive") should ===(false)
settings.AddLoggingReceive should ===(false)
@ -160,7 +160,7 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
}
{
val c = config.getConfig("akka.actor.default-mailbox")
val c = config.getConfig("pekko.actor.default-mailbox")
// general mailbox config
@ -177,19 +177,19 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
"not be amended for default reference in akka-actor" in {
val dynamicAccess = system.asInstanceOf[ExtendedActorSystem].dynamicAccess
val config = ActorSystem.Settings.amendSlf4jConfig(ConfigFactory.defaultReference(), dynamicAccess)
config.getStringList("akka.loggers").size() should ===(1)
config.getStringList("akka.loggers").get(0) should ===(classOf[DefaultLogger].getName)
config.getString("akka.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
config.getStringList("pekko.loggers").size() should ===(1)
config.getStringList("pekko.loggers").get(0) should ===(classOf[DefaultLogger].getName)
config.getString("pekko.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
}
"not be amended when akka-slf4j is not in classpath" in {
val dynamicAccess = system.asInstanceOf[ExtendedActorSystem].dynamicAccess
val config = ActorSystem.Settings.amendSlf4jConfig(
ConfigFactory.parseString("akka.use-slf4j = on").withFallback(ConfigFactory.defaultReference()),
ConfigFactory.parseString("pekko.use-slf4j = on").withFallback(ConfigFactory.defaultReference()),
dynamicAccess)
config.getStringList("akka.loggers").size() should ===(1)
config.getStringList("akka.loggers").get(0) should ===(classOf[DefaultLogger].getName)
config.getString("akka.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
config.getStringList("pekko.loggers").size() should ===(1)
config.getStringList("pekko.loggers").get(0) should ===(classOf[DefaultLogger].getName)
config.getString("pekko.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
}
}
}

4
akka-actor-tests/src/test/scala/org/apache/pekko/dispatch/DispatcherShutdownSpec.scala
View file

@ -29,8 +29,8 @@ class DispatcherShutdownSpec extends AnyWordSpec with Matchers {
.toList
.map(_.getThreadName)
.filter(name =>
name.startsWith("DispatcherShutdownSpec-akka.actor.default") || name.startsWith(
"DispatcherShutdownSpec-akka.actor.internal")) // nothing is run on default without any user actors started
name.startsWith("DispatcherShutdownSpec-pekko.actor.default") || name.startsWith(
"DispatcherShutdownSpec-pekko.actor.internal")) // nothing is run on default without any user actors started
.size
val system = ActorSystem("DispatcherShutdownSpec")

2
akka-actor-tests/src/test/scala/org/apache/pekko/event/AddressTerminatedTopicBenchSpec.scala
View file

@ -27,7 +27,7 @@ object AddressTerminatedTopicBenchSpec {
}
}
class AddressTerminatedTopicBenchSpec extends AkkaSpec("akka.loglevel=INFO") {
class AddressTerminatedTopicBenchSpec extends AkkaSpec("pekko.loglevel=INFO") {
import AddressTerminatedTopicBenchSpec._
"Subscribe and unsubscribe of AddressTerminated" must {

2
akka-actor-tests/src/test/scala/org/apache/pekko/event/EventBusSpec.scala
View file

@ -172,7 +172,7 @@ class ActorEventBusSpec(conf: Config) extends EventBusSpec("ActorEventBus", conf
import org.apache.pekko.event.ActorEventBusSpec._
def this() =
this(ConfigFactory.parseString("akka.actor.debug.event-stream = on").withFallback(AkkaSpec.testConf))
this(ConfigFactory.parseString("pekko.actor.debug.event-stream = on").withFallback(AkkaSpec.testConf))
type BusType = MyActorEventBus
def createNewEventBus(): BusType = new MyActorEventBus(system)

6
akka-actor-tests/src/test/scala/org/apache/pekko/event/EventStreamSpec.scala
View file

@ -15,7 +15,7 @@ import pekko.testkit.{ AkkaSpec, TestProbe }
object EventStreamSpec {
val config = ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = WARNING
loglevel = INFO
loggers = ["org.apache.pekko.event.EventStreamSpec$MyLog", "%s"]
@ -23,7 +23,7 @@ object EventStreamSpec {
""".format(Logging.StandardOutLogger.getClass.getName))
val configUnhandled = ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = WARNING
loglevel = WARNING
actor.debug.unhandled = on
@ -32,7 +32,7 @@ object EventStreamSpec {
""")
val configUnhandledWithDebug =
ConfigFactory.parseString("akka.actor.debug.event-stream = on").withFallback(configUnhandled)
ConfigFactory.parseString("pekko.actor.debug.event-stream = on").withFallback(configUnhandled)
final case class M(i: Int)

12
akka-actor-tests/src/test/scala/org/apache/pekko/event/LoggerSpec.scala
View file

@ -29,7 +29,7 @@ import pekko.util.Helpers
object LoggerSpec {
val defaultConfig = ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = "WARNING"
loglevel = "DEBUG" # test verifies debug
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"]
@ -37,7 +37,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf)
val slowConfig = ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = "ERROR"
loglevel = "ERROR"
loggers = ["org.apache.pekko.event.LoggerSpec$SlowLogger"]
@ -45,7 +45,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf)
val noLoggingConfig = ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = "OFF"
loglevel = "OFF"
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"]
@ -54,7 +54,7 @@ object LoggerSpec {
val multipleConfig =
ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = "OFF"
loglevel = "WARNING"
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1", "org.apache.pekko.event.LoggerSpec$TestLogger2"]
@ -62,7 +62,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf)
val ticket3165Config = ConfigFactory.parseString(s"""
akka {
pekko {
stdout-loglevel = "WARNING"
loglevel = "DEBUG" # test verifies debug
loggers = ["org.apache.pekko.event.LoggerSpec$$TestLogger1"]
@ -78,7 +78,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf)
val ticket3671Config = ConfigFactory.parseString("""
akka {
pekko {
stdout-loglevel = "WARNING"
loglevel = "WARNING"
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"]

8
akka-actor-tests/src/test/scala/org/apache/pekko/event/LoggingReceiveSpec.scala
View file

@ -29,16 +29,16 @@ class LoggingReceiveSpec extends AnyWordSpec with BeforeAndAfterAll {
import LoggingReceiveSpec._
val config = ConfigFactory.parseString("""
akka.loglevel=DEBUG # test verifies debug
pekko.loglevel=DEBUG # test verifies debug
""").withFallback(AkkaSpec.testConf)
val appLogging =
ActorSystem("logging", ConfigFactory.parseMap(Map("akka.actor.debug.receive" -> true).asJava).withFallback(config))
ActorSystem("logging", ConfigFactory.parseMap(Map("pekko.actor.debug.receive" -> true).asJava).withFallback(config))
val appAuto = ActorSystem(
"autoreceive",
ConfigFactory.parseMap(Map("akka.actor.debug.autoreceive" -> true).asJava).withFallback(config))
ConfigFactory.parseMap(Map("pekko.actor.debug.autoreceive" -> true).asJava).withFallback(config))
val appLifecycle = ActorSystem(
"lifecycle",
ConfigFactory.parseMap(Map("akka.actor.debug.lifecycle" -> true).asJava).withFallback(config))
ConfigFactory.parseMap(Map("pekko.actor.debug.lifecycle" -> true).asJava).withFallback(config))
val filter = TestEvent.Mute(EventFilter.custom {
case _: Logging.Debug => true

2
akka-actor-tests/src/test/scala/org/apache/pekko/event/jul/JavaLoggerSpec.scala
View file

@ -18,7 +18,7 @@ import pekko.testkit.AkkaSpec
object JavaLoggerSpec {
val config = ConfigFactory.parseString("""
akka {
pekko {
loglevel = INFO
loggers = ["org.apache.pekko.event.jul.JavaLogger"]
logging-filter = "org.apache.pekko.event.jul.JavaLoggingFilter"

4
akka-actor-tests/src/test/scala/org/apache/pekko/io/CapacityLimitSpec.scala
View file

@ -11,8 +11,8 @@ import pekko.testkit.{ AkkaSpec, TestProbe }
import pekko.testkit.SocketUtil.temporaryServerAddresses
class CapacityLimitSpec extends AkkaSpec("""
akka.loglevel = ERROR
akka.io.tcp.max-channels = 4
pekko.loglevel = ERROR
pekko.io.tcp.max-channels = 4
""") with TcpIntegrationSpecSupport {
"The TCP transport implementation" should {

12
akka-actor-tests/src/test/scala/org/apache/pekko/io/InetAddressDnsResolverSpec.scala
View file

@ -15,8 +15,8 @@ import pekko.testkit.{ AkkaSpec, TestActorRef }
@nowarn
class InetAddressDnsResolverSpec extends AkkaSpec("""
akka.io.dns.inet-address.positive-ttl = default
akka.io.dns.inet-address.negative-ttl = default
pekko.io.dns.inet-address.positive-ttl = default
pekko.io.dns.inet-address.negative-ttl = default
""") { thisSpecs =>
"The DNS resolver default ttl's" must {
@ -95,7 +95,7 @@ class InetAddressDnsResolverSpec extends AkkaSpec("""
Props(
classOf[InetAddressDnsResolver],
new SimpleDnsCache(),
system.settings.config.getConfig("akka.io.dns.inet-address")))
system.settings.config.getConfig("pekko.io.dns.inet-address")))
actorRef.underlyingActor
}
@ -123,8 +123,8 @@ class InetAddressDnsResolverSpec extends AkkaSpec("""
@nowarn
class InetAddressDnsResolverConfigSpec extends AkkaSpec("""
akka.io.dns.inet-address.positive-ttl = forever
akka.io.dns.inet-address.negative-ttl = never
pekko.io.dns.inet-address.positive-ttl = forever
pekko.io.dns.inet-address.negative-ttl = never
""") {
thisSpecs =>
@ -144,7 +144,7 @@ class InetAddressDnsResolverConfigSpec extends AkkaSpec("""
Props(
classOf[InetAddressDnsResolver],
new SimpleDnsCache(),
system.settings.config.getConfig("akka.io.dns.inet-address")))
system.settings.config.getConfig("pekko.io.dns.inet-address")))
actorRef.underlyingActor
}
}

10
akka-actor-tests/src/test/scala/org/apache/pekko/io/TcpConnectionSpec.scala
View file

@ -41,10 +41,10 @@ object TcpConnectionSpec {
}
class TcpConnectionSpec extends AkkaSpec("""
akka.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.tcp.trace-logging = on
akka.io.tcp.register-timeout = 500ms
pekko.loglevel = DEBUG
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.io.tcp.trace-logging = on
pekko.io.tcp.register-timeout = 500ms
""") with WithLogCapturing { thisSpecs =>
import TcpConnectionSpec._
@ -377,7 +377,7 @@ class TcpConnectionSpec extends AkkaSpec("""
"respect pull mode" in new EstablishedConnectionTest(pullMode = true) {
// override config to decrease default buffer size
def config =
ConfigFactory.parseString("akka.io.tcp.direct-buffer-size = 1k").withFallback(AkkaSpec.testConf)
ConfigFactory.parseString("pekko.io.tcp.direct-buffer-size = 1k").withFallback(AkkaSpec.testConf)
override implicit lazy val system: ActorSystem = ActorSystem("respectPullModeTest", config)
try run {

6
akka-actor-tests/src/test/scala/org/apache/pekko/io/TcpIntegrationSpec.scala
View file

@ -20,9 +20,9 @@ import pekko.testkit.WithLogCapturing
import pekko.util.ByteString
class TcpIntegrationSpec extends AkkaSpec("""
akka.loglevel = debug
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.tcp.trace-logging = on
pekko.loglevel = debug
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.io.tcp.trace-logging = on
""") with TcpIntegrationSpecSupport with TimeLimits with WithLogCapturing {
def verifyActorTermination(actor: ActorRef): Unit = {

2
akka-actor-tests/src/test/scala/org/apache/pekko/io/TcpListenerSpec.scala
View file

@ -21,7 +21,7 @@ import pekko.testkit.{ AkkaSpec, EventFilter, TestActorRef, TestProbe }
import pekko.testkit.SocketUtil
class TcpListenerSpec extends AkkaSpec("""
akka.io.tcp.batch-accept-limit = 2
pekko.io.tcp.batch-accept-limit = 2
""") {
"A TcpListener" must {

12
akka-actor-tests/src/test/scala/org/apache/pekko/io/UdpConnectedIntegrationSpec.scala
View file

@ -18,14 +18,14 @@ import pekko.testkit.WithLogCapturing
import pekko.util.ByteString
class UdpConnectedIntegrationSpec extends AkkaSpec("""
akka.loglevel = DEBUG
akka.actor.debug.lifecycle = on
akka.actor.debug.autoreceive = on
akka.io.udp-connected.trace-logging = on
pekko.loglevel = DEBUG
pekko.actor.debug.lifecycle = on
pekko.actor.debug.autoreceive = on
pekko.io.udp-connected.trace-logging = on
# issues with dns resolution of non existent host hanging with the
# Java native host resolution
akka.io.dns.resolver = async-dns
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.io.dns.resolver = async-dns
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with ImplicitSender with WithLogCapturing {
val addresses = temporaryServerAddresses(5, udp = true)

2
akka-actor-tests/src/test/scala/org/apache/pekko/io/UdpIntegrationSpec.scala
View file

@ -15,7 +15,7 @@ import pekko.testkit.SocketUtil.temporaryServerAddresses
import pekko.util.ByteString
class UdpIntegrationSpec extends AkkaSpec("""
akka.loglevel = INFO
pekko.loglevel = INFO
# tests expect to be able to mutate messages
""") with ImplicitSender {

14
akka-actor-tests/src/test/scala/org/apache/pekko/io/dns/AsyncDnsResolverIntegrationSpec.scala
View file

@ -33,13 +33,13 @@ object AsyncDnsResolverIntegrationSpec {
lazy val dockerDnsServerPort: Int = SocketUtil.temporaryLocalPort(Both)
implicit val defaultTimeout: Timeout = Timeout(10.seconds)
def conf = ConfigFactory.parseString(s"""
akka.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.dns.resolver = async-dns
akka.io.dns.async-dns.nameservers = ["localhost:${dockerDnsServerPort}"]
akka.io.dns.async-dns.search-domains = ["foo.test", "test"]
akka.io.dns.async-dns.ndots = 2
akka.io.dns.async-dns.resolve-timeout = ${defaultTimeout.duration.toSeconds}s
pekko.loglevel = DEBUG
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.io.dns.resolver = async-dns
pekko.io.dns.async-dns.nameservers = ["localhost:${dockerDnsServerPort}"]
pekko.io.dns.async-dns.search-domains = ["foo.test", "test"]
pekko.io.dns.async-dns.ndots = 2
pekko.io.dns.async-dns.resolve-timeout = ${defaultTimeout.duration.toSeconds}s
""")
}

8
akka-actor-tests/src/test/scala/org/apache/pekko/io/dns/internal/AsyncDnsManagerSpec.scala
View file

@ -21,10 +21,10 @@ import pekko.testkit.WithLogCapturing
// tests deprecated DNS API
@nowarn("msg=deprecated")
class AsyncDnsManagerSpec extends AkkaSpec("""
akka.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.dns.resolver = async-dns
akka.io.dns.async-dns.nameservers = default
pekko.loglevel = DEBUG
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.io.dns.resolver = async-dns
pekko.io.dns.async-dns.nameservers = default
""") with ImplicitSender with WithLogCapturing {
val dns = Dns(system).manager

4
akka-actor-tests/src/test/scala/org/apache/pekko/io/dns/internal/AsyncDnsResolverSpec.scala
View file

@ -23,8 +23,8 @@ import pekko.io.dns.internal.DnsClient.{ Answer, Question4, Question6, SrvQuesti
import pekko.testkit.{ AkkaSpec, TestProbe, WithLogCapturing }
class AsyncDnsResolverSpec extends AkkaSpec("""
akka.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.loglevel = DEBUG
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with WithLogCapturing {
val defaultConfig = ConfigFactory.parseString("""

4
akka-actor-tests/src/test/scala/org/apache/pekko/io/dns/internal/DnsClientSpec.scala
View file

@ -18,9 +18,9 @@ import pekko.testkit.{ AkkaSpec, ImplicitSender, TestProbe }
class DnsClientSpec extends AkkaSpec with ImplicitSender {
"The async DNS client" should {
val exampleRequest = Question4(42, "akka.io")
val exampleRequest = Question4(42, "pekko.io")
val exampleRequestMessage =
Message(42, MessageFlags(), questions = Seq(Question("akka.io", RecordType.A, RecordClass.IN)))
Message(42, MessageFlags(), questions = Seq(Question("pekko.io", RecordType.A, RecordClass.IN)))
val exampleResponseMessage = Message(42, MessageFlags(answer = true))
val exampleResponse = Answer(42, Nil)
val dnsServerAddress = InetSocketAddress.createUnresolved("foo", 53)

2
akka-actor-tests/src/test/scala/org/apache/pekko/io/dns/internal/TcpDnsClientSpec.scala
View file

@ -21,7 +21,7 @@ class TcpDnsClientSpec extends AkkaSpec with ImplicitSender {
"The async TCP DNS client" should {
val exampleRequestMessage =
Message(42, MessageFlags(), questions = Seq(Question("akka.io", RecordType.A, RecordClass.IN)))
Message(42, MessageFlags(), questions = Seq(Question("pekko.io", RecordType.A, RecordClass.IN)))
val exampleResponseMessage = Message(42, MessageFlags(answer = true))
val dnsServerAddress = InetSocketAddress.createUnresolved("foo", 53)
val localAddress = InetSocketAddress.createUnresolved("localhost", 13441)

4
akka-actor-tests/src/test/scala/org/apache/pekko/pattern/AskSpec.scala
View file

@ -19,8 +19,8 @@ import pekko.util.Timeout
@nowarn
class AskSpec extends AkkaSpec("""
akka.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.loglevel = DEBUG
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with WithLogCapturing {
"The “ask” pattern" must {

4
akka-actor-tests/src/test/scala/org/apache/pekko/pattern/BackoffOnRestartSupervisorSpec.scala
View file

@ -55,8 +55,8 @@ class TestParentActor(probe: ActorRef, supervisorProps: Props) extends Actor {
}
class BackoffOnRestartSupervisorSpec extends AkkaSpec("""
akka.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
pekko.loglevel = DEBUG
pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with WithLogCapturing with ImplicitSender {
def supervisorProps(probeRef: ActorRef) = {

2
akka-actor-tests/src/test/scala/org/apache/pekko/pattern/CircuitBreakerSpec.scala
View file

@ -84,7 +84,7 @@ object CircuitBreakerSpec {
}
class CircuitBreakerSpec extends AkkaSpec("""
akka.circuit-breaker {
pekko.circuit-breaker {
identified {
max-failures = 1
call-timeout = 100 ms

4
akka-actor-tests/src/test/scala/org/apache/pekko/routing/BalancingSpec.scala
View file

@ -61,8 +61,8 @@ object BalancingSpec {
}
class BalancingSpec extends AkkaSpec("""
akka.loglevel=debug
akka.actor.deployment {
pekko.loglevel=debug
pekko.actor.deployment {
/balancingPool-2 {
router = balancing-pool
nr-of-instances = 5

2
akka-actor-tests/src/test/scala/org/apache/pekko/routing/ConfiguredLocalRoutingSpec.scala
View file

@ -26,7 +26,7 @@ import pekko.testkit.TestProbe
object ConfiguredLocalRoutingSpec {
val config = """
akka {
pekko {
actor {
default-dispatcher {
executor = "thread-pool-executor"

4
akka-actor-tests/src/test/scala/org/apache/pekko/routing/ConsistentHashingRouterSpec.scala
View file

@ -21,11 +21,11 @@ import pekko.testkit.AkkaSpec
object ConsistentHashingRouterSpec {
val config = """
akka.actor {
pekko.actor {
# consistent hashing is serializing the hash key, unless it's bytes or string
allow-java-serialization = on
}
akka.actor.deployment {
pekko.actor.deployment {
/router1 {
router = consistent-hashing-pool
nr-of-instances = 3

4
akka-actor-tests/src/test/scala/org/apache/pekko/routing/ResizerSpec.scala
View file

@ -19,7 +19,7 @@ import pekko.testkit.TestEvent._
object ResizerSpec {
val config = """
akka.actor.deployment {
pekko.actor.deployment {
/router1 {
router = round-robin-pool
resizer {
@ -53,7 +53,7 @@ class ResizerSpec extends AkkaSpec(ResizerSpec.config) with DefaultTimeout with
"Resizer fromConfig" must {
def parseCfg(cfgString: String): Config = {
val referenceCfg = ConfigFactory.defaultReference(ActorSystem.findClassLoader())
ConfigFactory.parseString(cfgString).withFallback(referenceCfg.getConfig("akka.actor.deployment.default"))
ConfigFactory.parseString(cfgString).withFallback(referenceCfg.getConfig("pekko.actor.deployment.default"))
}
"load DefaultResizer from config when resizer is enabled" in {

4
akka-actor-tests/src/test/scala/org/apache/pekko/routing/RoutingSpec.scala
View file

@ -21,7 +21,7 @@ import pekko.testkit._
object RoutingSpec {
val config = """
akka.actor.deployment {
pekko.actor.deployment {
/router1 {
router = round-robin-pool
nr-of-instances = 3
@ -239,7 +239,7 @@ class RoutingSpec extends AkkaSpec(RoutingSpec.config) with DefaultTimeout with
val sys = ActorSystem(
"FromConfig",
ConfigFactory
.parseString("akka.actor.deployment./routed.router=round-robin-pool")
.parseString("pekko.actor.deployment./routed.router=round-robin-pool")
.withFallback(system.settings.config))
try {
sys.actorOf(FromConfig.props(routeeProps = Props[TestActor]()), "routed")

2
akka-actor-tests/src/test/scala/org/apache/pekko/serialization/AsyncSerializeSpec.scala
View file

@ -20,7 +20,7 @@ object AsyncSerializeSpec {
case class Message4(str: String)
val config = ConfigFactory.parseString(s"""
akka {
pekko {
actor {
serializers {
async = "org.apache.pekko.serialization.AsyncSerializeSpec$$TestAsyncSerializer"

2
akka-actor-tests/src/test/scala/org/apache/pekko/serialization/DisabledJavaSerializerWarningSpec.scala
View file

@ -17,7 +17,7 @@ object DisabledJavaSerializerWarningSpec {
}
class DisabledJavaSerializerWarningSpec extends AkkaSpec("""
akka.actor {
pekko.actor {
allow-java-serialization = off
serialize-messages = on
no-serialization-verification-needed-class-prefix = []

14
akka-actor-tests/src/test/scala/org/apache/pekko/serialization/SerializationSetupSpec.scala
View file

@ -55,7 +55,7 @@ object SerializationSetupSpec {
val bootstrapSettings = BootstrapSetup(
None,
Some(ConfigFactory.parseString("""
akka {
pekko {
actor {
allow-java-serialization = on
@ -74,7 +74,7 @@ object SerializationSetupSpec {
val noJavaSerializationSystem = ActorSystem(
"SerializationSettingsSpec" + "NoJavaSerialization",
ConfigFactory.parseString("""
akka {
pekko {
actor {
allow-java-serialization = off
# this is by default on, but tests are running with off, use defaults here
@ -114,9 +114,9 @@ class SerializationSetupSpec
"fail during ActorSystem creation when misconfigured" in {
val config =
ConfigFactory.parseString("""
akka.loglevel = OFF
akka.stdout-loglevel = OFF
akka.actor.serializers.doe = "john.is.not.here"
pekko.loglevel = OFF
pekko.stdout-loglevel = OFF
pekko.actor.serializers.doe = "john.is.not.here"
""").withFallback(ConfigFactory.load())
a[ClassNotFoundException] should be thrownBy {
@ -142,7 +142,7 @@ class SerializationSetupSpec
val addedJavaSerializationProgramaticallyButDisabledSettings = BootstrapSetup(
None,
Some(ConfigFactory.parseString("""
akka {
pekko {
loglevel = debug
actor {
allow-java-serialization = off
@ -163,7 +163,7 @@ class SerializationSetupSpec
"throw if passed system to JavaSerializer has allow-java-serialization = off" in {
intercept[DisabledJavaSerializer.JavaSerializationException] {
new JavaSerializer(noJavaSerializationSystem.asInstanceOf[ExtendedActorSystem])
}.getMessage should include("akka.actor.allow-java-serialization = off")
}.getMessage should include("pekko.actor.allow-java-serialization = off")
intercept[DisabledJavaSerializer.JavaSerializationException] {
SerializationExtension(addedJavaSerializationViaSettingsSystem)

26
akka-actor-tests/src/test/scala/org/apache/pekko/serialization/SerializeSpec.scala
View file

@ -28,7 +28,7 @@ import pekko.util.ByteString
object SerializationTests {
val serializeConf = s"""
akka {
pekko {
actor {
serializers {
test = "org.apache.pekko.serialization.NoopSerializer"
@ -92,7 +92,7 @@ object SerializationTests {
}
val verifySerializabilityConf = """
akka {
pekko {
actor {
serialize-messages = on
serialize-creators = on
@ -128,8 +128,8 @@ object SerializationTests {
val referenceConf = ConfigFactory.defaultReference()
val conf = ConfigFactory
.parseString("""
akka.actor.warn-about-java-serializer-usage = on
akka.actor.allow-java-serialization = on
pekko.actor.warn-about-java-serializer-usage = on
pekko.actor.allow-java-serialization = on
""")
.withFallback(ConfigFactory.parseString(serializeConf))
.withFallback(AkkaSpec.testConf.withFallback(referenceConf))
@ -137,7 +137,7 @@ object SerializationTests {
}
val systemMessageMultiSerializerConf = """
akka {
pekko {
actor {
serializers {
test = "org.apache.pekko.serialization.NoopSerializer"
@ -277,7 +277,7 @@ class SerializeSpec extends AkkaSpec(SerializationTests.serializeConf) {
val sys = ActorSystem(
"SerializeSpec",
ConfigFactory.parseString(s"""
akka {
pekko {
actor {
serializers {
test = "org.apache.pekko.serialization.NoopSerializer"
@ -504,9 +504,9 @@ class AllowJavaSerializationSpec extends AkkaSpec(SerializationTests.allowJavaSe
class NoVerificationWarningSpec
extends AkkaSpec(ConfigFactory.parseString("""
akka.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = on
akka.actor.warn-on-no-serialization-verification = on
pekko.actor.allow-java-serialization = on
pekko.actor.warn-about-java-serializer-usage = on
pekko.actor.warn-on-no-serialization-verification = on
""")) {
val ser = SerializationExtension(system)
@ -530,9 +530,9 @@ class NoVerificationWarningSpec
class NoVerificationWarningOffSpec
extends AkkaSpec(ConfigFactory.parseString("""
akka.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = on
akka.actor.warn-on-no-serialization-verification = off
pekko.actor.allow-java-serialization = on
pekko.actor.warn-about-java-serializer-usage = on
pekko.actor.warn-on-no-serialization-verification = off
""")) {
val ser = SerializationExtension(system)
@ -563,7 +563,7 @@ class SerializerDeadlockSpec extends AkkaSpec {
val sys = ActorSystem(
"SerializerDeadlockSpec",
ConfigFactory.parseString("""
akka {
pekko {
actor {
creation-timeout = 1s
serializers {

2
akka-actor-typed-tests/src/test/java/jdocs/org/apache/pekko/typed/BubblingSampleTest.java
View file

@ -22,7 +22,7 @@ public class BubblingSampleTest extends JUnitSuite {
@ClassRule
public static final TestKitJunitResource testKit =
new TestKitJunitResource("akka.loglevel = off");
new TestKitJunitResource("pekko.loglevel = off");
@Rule public final LogCapturing logCapturing = new LogCapturing();

2
akka-actor-typed-tests/src/test/java/jdocs/org/apache/pekko/typed/IntroTest.java
View file

@ -170,7 +170,7 @@ public interface IntroTest {
private HelloWorldMain(ActorContext<SayHello> context) {
super(context);
final String dispatcherPath = "akka.actor.default-blocking-io-dispatcher";
final String dispatcherPath = "pekko.actor.default-blocking-io-dispatcher";
Props greeterProps = DispatcherSelector.fromConfig(dispatcherPath);
greeter = getContext().spawn(HelloWorld.create(), "greeter", greeterProps);
}

2
akka-actor-typed-tests/src/test/java/org/apache/pekko/actor/typed/ExtensionsTest.java
View file

@ -52,7 +52,7 @@ public class ExtensionsTest extends JUnitSuite {
public void loadJavaExtensionsFromConfig() {
Config cfg =
ConfigFactory.parseString(
"akka.actor.typed.extensions += \"org.apache.pekko.actor.typed.ExtensionsTest$MyExtension\"")
"pekko.actor.typed.extensions += \"org.apache.pekko.actor.typed.ExtensionsTest$MyExtension\"")
.resolve();
final ActorSystem<Object> system =
ActorSystem.create(Behaviors.empty(), "loadJavaExtensionsFromConfig", cfg);

4
akka-actor-typed-tests/src/test/java/org/apache/pekko/actor/typed/javadsl/ActorLoggingTest.java
View file

@ -28,8 +28,8 @@ public class ActorLoggingTest extends JUnitSuite {
public static final TestKitJunitResource testKit =
new TestKitJunitResource(
ConfigFactory.parseString(
"akka.loglevel = INFO\n"
+ "akka.loggers = [\"org.apache.pekko.testkit.TestEventListener\"]"));
"pekko.loglevel = INFO\n"
+ "pekko.loggers = [\"org.apache.pekko.testkit.TestEventListener\"]"));
interface Protocol {
String getTransactionId();

4
akka-actor-typed-tests/src/test/scala/docs/org/apache/pekko/typed/DispatchersDocSpec.scala
View file

@ -71,12 +71,12 @@ class DispatchersDocSpec
val withDefault: Future[ActorRef[WhichDispatcher]] =
actor.ask(Spawn(giveMeYourDispatcher, "default", Props.empty, _))
withDefault.futureValue ! WhichDispatcher(probe.ref)
probe.receiveMessage().id shouldEqual "akka.actor.default-dispatcher"
probe.receiveMessage().id shouldEqual "pekko.actor.default-dispatcher"
val withBlocking: Future[ActorRef[WhichDispatcher]] =
actor.ask(Spawn(giveMeYourDispatcher, "default", DispatcherSelector.blocking(), _))
withBlocking.futureValue ! WhichDispatcher(probe.ref)
probe.receiveMessage().id shouldEqual "akka.actor.default-blocking-io-dispatcher"
probe.receiveMessage().id shouldEqual "pekko.actor.default-blocking-io-dispatcher"
val withCustom: Future[ActorRef[WhichDispatcher]] =
actor.ask(Spawn(giveMeYourDispatcher, "default", DispatcherSelector.fromConfig("your-dispatcher"), _))

2
akka-actor-typed-tests/src/test/scala/docs/org/apache/pekko/typed/FaultToleranceDocSpec.scala
View file

@ -81,7 +81,7 @@ object FaultToleranceDocSpec {
@nowarn("msg=never used")
class FaultToleranceDocSpec extends ScalaTestWithActorTestKit("""
# silenced to not put noise in test logs
akka.loglevel = off
pekko.loglevel = off
""") with AnyWordSpecLike {
import FaultToleranceDocSpec._

2
akka-actor-typed-tests/src/test/scala/docs/org/apache/pekko/typed/IntroSpec.scala
View file

@ -113,7 +113,7 @@ object IntroSpec {
// #hello-world-main-with-dispatchers
def apply(): Behavior[SayHello] =
Behaviors.setup { context =>
val dispatcherPath = "akka.actor.default-blocking-io-dispatcher"
val dispatcherPath = "pekko.actor.default-blocking-io-dispatcher"
val props = DispatcherSelector.fromConfig(dispatcherPath)
val greeter = context.spawn(HelloWorld(), "greeter", props)

2
akka-actor-typed-tests/src/test/scala/docs/org/apache/pekko/typed/RouterSpec.scala
View file

@ -49,7 +49,7 @@ object RouterSpec {
// format: ON
}
class RouterSpec extends ScalaTestWithActorTestKit("akka.loglevel=warning") with AnyWordSpecLike with LogCapturing {
class RouterSpec extends ScalaTestWithActorTestKit("pekko.loglevel=warning") with AnyWordSpecLike with LogCapturing {
import RouterSpec._
"The routing sample" must {

2
akka-actor-typed-tests/src/test/scala/docs/org/apache/pekko/typed/extensions/ExtensionDocSpec.scala
View file

@ -46,7 +46,7 @@ class DatabasePool(system: ActorSystem[_]) extends Extension {
object ExtensionDocSpec {
val config = ConfigFactory.parseString("""
#config
akka.actor.typed.extensions = ["org.apache.pekko.akka.extensions.DatabasePool"]
pekko.actor.typed.extensions = ["org.apache.pekko.pekko.extensions.DatabasePool"]
#config
""")

4
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/AskSpec.scala
View file

@ -30,8 +30,8 @@ object AskSpec {
}
class AskSpec extends ScalaTestWithActorTestKit("""
akka.loglevel=DEBUG
akka.actor.debug.event-stream = on
pekko.loglevel=DEBUG
pekko.actor.debug.event-stream = on
""") with AnyWordSpecLike with LogCapturing {
import AskSpec._

16
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/ExtensionsSpec.scala
View file

@ -69,7 +69,7 @@ class AccessSystemFromConstructor(system: ActorSystem[_]) extends Extension {
object ExtensionsSpec {
val config = ConfigFactory.parseString("""
akka.actor.typed {
pekko.actor.typed {
library-extensions += "org.apache.pekko.actor.typed.InstanceCountingExtension"
}
""").resolve()
@ -115,7 +115,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Some(
ConfigFactory.parseString(
"""
akka.actor.typed.extensions = ["org.apache.pekko.actor.typed.DummyExtension1$", "org.apache.pekko.actor.typed.SlowExtension$"]
pekko.actor.typed.extensions = ["org.apache.pekko.actor.typed.DummyExtension1$", "org.apache.pekko.actor.typed.SlowExtension$"]
"""))) { sys =>
sys.hasExtension(DummyExtension1) should ===(true)
sys.extension(DummyExtension1) shouldBe a[DummyExtension1]
@ -130,7 +130,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Behaviors.empty[Any],
"ExtensionsSpec04",
ConfigFactory.parseString("""
akka.actor.typed.extensions = ["org.apache.pekko.actor.typed.FailingToLoadExtension$"]
pekko.actor.typed.extensions = ["org.apache.pekko.actor.typed.FailingToLoadExtension$"]
"""))
}
@ -155,7 +155,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
"allow for auto-loading of library-extensions" in
withEmptyActorSystem("ExtensionsSpec06") { sys =>
val listedExtensions = sys.settings.config.getStringList("akka.actor.typed.library-extensions")
val listedExtensions = sys.settings.config.getStringList("pekko.actor.typed.library-extensions")
listedExtensions.size should be > 0
// could be initialized by other tests, so at least once
InstanceCountingExtension.createCount.get() should be > 0
@ -167,7 +167,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
"ExtensionsSpec07",
Some(
ConfigFactory.parseString(
"""akka.actor.typed.library-extensions += "org.apache.pekko.actor.typed.FailingToLoadExtension$""""))) {
"""pekko.actor.typed.library-extensions += "org.apache.pekko.actor.typed.FailingToLoadExtension$""""))) {
_ =>
()
}
@ -178,7 +178,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
withEmptyActorSystem(
"ExtensionsSpec08",
Some(ConfigFactory.parseString(
"""akka.actor.typed.library-extensions += "org.apache.pekko.actor.typed.MissingExtension""""))) { _ =>
"""pekko.actor.typed.library-extensions += "org.apache.pekko.actor.typed.MissingExtension""""))) { _ =>
()
}
}
@ -230,7 +230,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Some(
ConfigFactory.parseString(
"""
akka.actor.typed.extensions = ["org.apache.pekko.actor.typed.DummyExtension1$", "org.apache.pekko.actor.typed.SlowExtension$"]
pekko.actor.typed.extensions = ["org.apache.pekko.actor.typed.DummyExtension1$", "org.apache.pekko.actor.typed.SlowExtension$"]
""")),
Some(ActorSystemSetup(new DummyExtension1Setup(_ => new DummyExtension1ViaSetup)))) { sys =>
sys.hasExtension(DummyExtension1) should ===(true)
@ -248,7 +248,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Some(
ConfigFactory.parseString(
"""
akka.actor.typed.extensions = ["org.apache.pekko.actor.typed.AccessSystemFromConstructorExtensionId$"]
pekko.actor.typed.extensions = ["org.apache.pekko.actor.typed.AccessSystemFromConstructorExtensionId$"]
""")),
None) { sys =>
AccessSystemFromConstructorExtensionId(sys) // would throw if it couldn't

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/LocalActorRefProviderLogMessagesSpec.scala
View file

@ -11,7 +11,7 @@ import org.scalatest.wordspec.AnyWordSpecLike
object LocalActorRefProviderLogMessagesSpec {
val config = """
akka {
pekko {
loglevel = DEBUG # test verifies debug
log-dead-letters = on
actor {

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/LogMessagesSpec.scala
View file

@ -16,7 +16,7 @@ import pekko.actor.typed.scaladsl.Behaviors
import pekko.actor.typed.scaladsl.adapter._
class LogMessagesSpec extends ScalaTestWithActorTestKit("""
akka.loglevel = DEBUG # test verifies debug
pekko.loglevel = DEBUG # test verifies debug
""") with AnyWordSpecLike with LogCapturing {
implicit val classic: actor.ActorSystem = system.toClassic

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/SupervisionSpec.scala
View file

@ -261,7 +261,7 @@ class StubbedSupervisionSpec extends AnyWordSpec with Matchers with LogCapturing
}
class SupervisionSpec extends ScalaTestWithActorTestKit("""
akka.log-dead-letters = off
pekko.log-dead-letters = off
""") with AnyWordSpecLike with LogCapturing {
import BehaviorInterceptor._

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/coexistence/ClassicSupervisingTypedSpec.scala
View file

@ -55,7 +55,7 @@ class ClassicSupervisingTypedSpec extends AnyWordSpecLike with LogCapturing with
val classicSystem = pekko.actor.ActorSystem(
"ClassicSupervisingTypedSpec",
ConfigFactory.parseString("""
akka.actor.testkit.typed.expect-no-message-default = 50 ms
pekko.actor.testkit.typed.expect-no-message-default = 50 ms
"""))
val classicTestKit = new pekko.testkit.TestKit(classicSystem)
implicit val classicSender: u.ActorRef = classicTestKit.testActor

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/coexistence/TypedSupervisingClassicSpec.scala
View file

@ -44,7 +44,7 @@ object TypedSupervisingClassicSpec {
}
class TypedSupervisingClassicSpec extends ScalaTestWithActorTestKit("""
akka.loglevel = INFO
pekko.loglevel = INFO
""".stripMargin) with AnyWordSpecLike with LogCapturing {
import TypedSupervisingClassicSpec._

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/ConsumerControllerSpec.scala
View file

@ -18,7 +18,7 @@ import pekko.serialization.SerializationExtension
class ConsumerControllerSpec
extends ScalaTestWithActorTestKit(ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller {
pekko.reliable-delivery.consumer-controller {
flow-control-window = 20
resend-interval-min = 1s
}

4
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/DurableProducerControllerSpec.scala
View file

@ -23,8 +23,8 @@ import pekko.util.ByteString
class DurableProducerControllerSpec
extends ScalaTestWithActorTestKit(
ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20
akka.reliable-delivery.consumer-controller.resend-interval-min = 1s
pekko.reliable-delivery.consumer-controller.flow-control-window = 20
pekko.reliable-delivery.consumer-controller.resend-interval-min = 1s
""").withFallback(TestSerializer.config))
with AnyWordSpecLike
with LogCapturing {

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/DurableWorkPullingSpec.scala
View file

@ -22,7 +22,7 @@ import pekko.actor.typed.receptionist.ServiceKey
class DurableWorkPullingSpec
extends ScalaTestWithActorTestKit("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20
pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""")
with AnyWordSpecLike
with LogCapturing {

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/ProducerControllerSpec.scala
View file

@ -19,7 +19,7 @@ import pekko.actor.typed.delivery.internal.ProducerControllerImpl
class ProducerControllerSpec
extends ScalaTestWithActorTestKit(
ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20
pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""").withFallback(TestSerializer.config))
with AnyWordSpecLike
with LogCapturing {

4
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/ReliableDeliveryRandomSpec.scala
View file

@ -25,7 +25,7 @@ import pekko.actor.typed.scaladsl.LoggerOps
object ReliableDeliveryRandomSpec {
val config: Config = ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller {
pekko.reliable-delivery.consumer-controller {
flow-control-window = 20
resend-interval-min = 500 ms
resend-interval-max = 2 s
@ -215,5 +215,5 @@ class ReliableDeliveryRandomSpec(config: Config)
class ReliableDeliveryRandomChunkedSpec
extends ReliableDeliveryRandomSpec(
ConfigFactory.parseString("""
akka.reliable-delivery.producer-controller.chunk-large-messages = 1b
pekko.reliable-delivery.producer-controller.chunk-large-messages = 1b
""").withFallback(TestSerializer.config).withFallback(ReliableDeliveryRandomSpec.config))

4
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/ReliableDeliverySpec.scala
View file

@ -16,7 +16,7 @@ import pekko.actor.testkit.typed.scaladsl.ScalaTestWithActorTestKit
object ReliableDeliverySpec {
val config: Config = ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20
pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""")
}
@ -209,5 +209,5 @@ class ReliableDeliverySpec(config: Config)
class ReliableDeliveryChunkedSpec
extends ReliableDeliverySpec(
ConfigFactory.parseString("""
akka.reliable-delivery.producer-controller.chunk-large-messages = 1b
pekko.reliable-delivery.producer-controller.chunk-large-messages = 1b
""").withFallback(TestSerializer.config).withFallback(ReliableDeliverySpec.config))

4
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/TestConsumer.scala
View file

@ -126,8 +126,8 @@ class TestConsumer(
object TestSerializer {
val config: Config = ConfigFactory.parseString(s"""
akka.actor.serializers.delivery-test = ${classOf[TestSerializer].getName}
akka.actor.serialization-bindings {
pekko.actor.serializers.delivery-test = ${classOf[TestSerializer].getName}
pekko.actor.serialization-bindings {
"${classOf[TestConsumer.Job].getName}" = delivery-test
}
""")

2
akka-actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/delivery/WorkPullingSpec.scala
View file

@ -19,7 +19,7 @@ import pekko.actor.typed.receptionist.ServiceKey
class WorkPullingSpec
extends ScalaTestWithActorTestKit("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20
pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""")
with AnyWordSpecLike
with LogCapturing {

Some files were not shown because too many files have changed in this diff Show more