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

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

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

@ -28,7 +28,7 @@ jobs:
uses: coursier/cache-action@v6.4.0 uses: coursier/cache-action@v6.4.0
- name: create the Akka site - 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 - name: Install Coursier command line tool
run: curl -fLo cs https://git.io/coursier-cli-linux && chmod +x cs && ./cs 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: | run: |
cat multi-node-test.hosts cat multi-node-test.hosts
sbtx -jvm-opts .jvmopts-ci \ sbtx -jvm-opts .jvmopts-ci \
-Dakka.test.timefactor=2 \ -Dpekko.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \ -Dpekko.actor.testkit.typed.timefactor=2 \
-Dakka.test.tags.exclude=gh-exclude,timing \ -Dpekko.test.tags.exclude=gh-exclude,timing \
-Dakka.cluster.assert=on \ -Dpekko.cluster.assert=on \
-Dsbt.override.build.repos=false \ -Dsbt.override.build.repos=false \
-Dakka.test.multi-node=true \ -Dpekko.test.multi-node=true \
-Dakka.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \ -Dpekko.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \
-Dakka.test.multi-node.java=${JAVA_HOME}/bin/java \ -Dpekko.test.multi-node.java=${JAVA_HOME}/bin/java \
-Dmultinode.XX:MetaspaceSize=128M \ -Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms512M \ -Dmultinode.Xms512M \
-Dmultinode.Xmx512M \ -Dmultinode.Xmx512M \
@ -136,15 +136,15 @@ jobs:
run: | run: |
cat multi-node-test.hosts cat multi-node-test.hosts
sbtx -jvm-opts .jvmopts-ci \ sbtx -jvm-opts .jvmopts-ci \
-Dakka.test.timefactor=2 \ -Dpekko.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \ -Dpekko.actor.testkit.typed.timefactor=2 \
-Dakka.cluster.assert=on \ -Dpekko.cluster.assert=on \
-Dakka.remote.artery.transport=aeron-udp \ -Dpekko.remote.artery.transport=aeron-udp \
-Dsbt.override.build.repos=false \ -Dsbt.override.build.repos=false \
-Dakka.test.tags.exclude=gh-exclude,gh-exclude-aeron,timing \ -Dpekko.test.tags.exclude=gh-exclude,gh-exclude-aeron,timing \
-Dakka.test.multi-node=true \ -Dpekko.test.multi-node=true \
-Dakka.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \ -Dpekko.test.multi-node.targetDirName=${PWD}/target/${{ github.run_id }} \
-Dakka.test.multi-node.java=${JAVA_HOME}/bin/java \ -Dpekko.test.multi-node.java=${JAVA_HOME}/bin/java \
-Dmultinode.XX:MetaspaceSize=128M \ -Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms512M \ -Dmultinode.Xms512M \
-Dmultinode.Xmx512M \ -Dmultinode.Xmx512M \

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

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

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

@ -33,7 +33,7 @@ jobs:
chmod 600 /tmp/id_rsa chmod 600 /tmp/id_rsa
ssh-add /tmp/id_rsa ssh-add /tmp/id_rsa
# using Scala 2.13 here to avoid the infamous problem with missing AskSupport in classpath # 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: env:
SCP_SECRET: ${{ secrets.SCP_SECRET }} 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 # note that this is not running any multi-jvm tests (yet) because multi-in-test=false
run: | run: |
sbtx -jvm-opts .jvmopts-ci \ sbtx -jvm-opts .jvmopts-ci \
-Dakka.log.timestamps=true \ -Dpekko.log.timestamps=true \
-Dakka.test.timefactor=2 \ -Dpekko.test.timefactor=2 \
-Dakka.actor.testkit.typed.timefactor=2 \ -Dpekko.actor.testkit.typed.timefactor=2 \
-Dakka.test.multi-in-test=false \ -Dpekko.test.multi-in-test=false \
-Dakka.test.tags.exclude=gh-exclude,timing \ -Dpekko.test.tags.exclude=gh-exclude,timing \
-Dmultinode.XX:MetaspaceSize=128M \ -Dmultinode.XX:MetaspaceSize=128M \
-Dmultinode.Xms256M \ -Dmultinode.Xms256M \
-Dmultinode.Xmx256M \ -Dmultinode.Xmx256M \

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

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

2
.jvmopts-ci
View file

@ -12,4 +12,4 @@
-XX:MetaspaceSize=512M -XX:MetaspaceSize=512M
-XX:-ClassUnloadingWithConcurrentMark -XX:-ClassUnloadingWithConcurrentMark
-Djava.security.egd=file:/dev/./urandom -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), [this StackOverflow answer](https://stackoverflow.com/a/31569861/354132),
though note that this syntax may not correctly render as Javadoc. 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 #### 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: 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 ```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. 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: You can exclude the same kind of tests in your local build by starting sbt with:
```shell ```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: It is also possible to exclude groups of test by their names. For example:
```shell ```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`. 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: to any non-empty string value when starting up sbt:
```shell ```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. 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. # This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf. # 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 # Factor by which to scale timeouts during tests, e.g. to account for shared
# build system load. # build system load.
timefactor = 1.0 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 { 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 = def apply(system: ActorSystem[_]): TestKitSettings =
Ext(system).settings Ext(system).settings
/** /**
* Reads configuration settings from given `Config` that * 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 = def apply(config: Config): TestKitSettings =
new TestKitSettings(config) 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 = def create(system: ActorSystem[_]): TestKitSettings =
apply(system) apply(system)
/** /**
* Reads configuration settings from given `Config` that * 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 = def create(config: Config): TestKitSettings =
new TestKitSettings(config) new TestKitSettings(config)
@ -49,7 +49,7 @@ object TestKitSettings {
} }
private class Ext(system: ActorSystem[_]) extends Extension { 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. * 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 * 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. * duration.
*/ */
def withOccurrences(newOccurrences: Int): LoggingTestKit 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 * 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. * as often as requested by its `occurrences` parameter specifies.
* *
* Care is taken to remove the testkit when the block is finished or aborted. * 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` * Obtain time remaining for execution of the innermost enclosing `within`
* block or missing that it returns the properly dilated default for this * 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 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 * take maximum wait times are available in a version which implicitly uses
* the remaining time governed by the innermost enclosing `within` block. * 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. * while the min Duration is not.
* *
* {{{ * {{{
@ -156,8 +156,8 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
def expectNoMessage(max: Duration): Unit 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`. * 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 "akka.actor.testkit.typed.timefactor". * That timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/ */
def expectNoMessage(): Unit 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. * 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 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. * 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] def receiveSeveralMessages(n: Int, max: Duration): JList[M]
@ -211,7 +211,7 @@ abstract class TestProbe[M] extends RecipientRef[M] { this: InternalRecipientRef
* partial function). * partial function).
* *
* @param max Max total time without the fisher function returning `CompleteFishing` before failing. * @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 * @return The messages accepted in the order they arrived
*/ */
def fishForMessage(max: Duration, fisher: java.util.function.Function[M, FishingOutcome]): java.util.List[M] 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 * Expect the given actor to be stopped or stop within the given timeout or
* throw an [[AssertionError]]. * 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 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. * 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 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. * 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 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. * 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 * 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. * duration.
*/ */
def withOccurrences(newOccurrences: Int): LoggingTestKit 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 * 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. * as often as requested by its `occurrences` parameter specifies.
* *
* Care is taken to remove the testkit when the block is finished or aborted. * 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 * 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. * as often as requested by its `occurrences` parameter specifies.
* *
* Care is taken to remove the testkit when the block is finished or aborted. * 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 = val config: Config =
ConfigFactory.parseString( 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]] * 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` * Obtain time remaining for execution of the innermost enclosing `within`
* block or missing that it returns the properly dilated default for this * 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 def remainingOrDefault: FiniteDuration
@ -94,7 +94,7 @@ object TestProbe {
* take maximum wait times are available in a version which implicitly uses * take maximum wait times are available in a version which implicitly uses
* the remaining time governed by the innermost enclosing `within` block. * 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. * while the min Duration is not.
* *
* {{{ * {{{
@ -141,8 +141,8 @@ object TestProbe {
def expectNoMessage(max: FiniteDuration): Unit 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`. * 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 "akka.actor.testkit.typed.timefactor". * That timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/ */
def expectNoMessage(): Unit def expectNoMessage(): Unit
@ -175,7 +175,7 @@ object TestProbe {
/** /**
* Receive `n` messages in a row before the given deadline. * 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] def receiveMessages(n: Int, max: FiniteDuration): immutable.Seq[M]
@ -194,7 +194,7 @@ object TestProbe {
* partial function). * partial function).
* *
* @param max Max total time without the fisher function returning `CompleteFishing` before failing. * @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 * @return The messages accepted in the order they arrived
*/ */
def fishForMessage(max: FiniteDuration, hint: String)(fisher: M => FishingOutcome): immutable.Seq[M] 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. * 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 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 * 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. * 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 // #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 // #parse-string
; ;
// #fallback-application-conf // #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()) .withFallback(ConfigFactory.load())
// #fallback-application-conf // #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 // #parse-string
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.log-config-on-start = on pekko.log-config-on-start = on
""") """)
// #parse-string // #parse-string
// #fallback-application-conf // #fallback-application-conf
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.log-config-on-start = on pekko.log-config-on-start = on
""").withFallback(ConfigFactory.load()) """).withFallback(ConfigFactory.load())
// #fallback-application-conf // #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( extends ScalaTestWithActorTestKit(
""" """
# increase to avoid spurious failures in "find unexpected async events withOccurrences(0)" # 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 AnyWordSpecLike
with LogCapturing { 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 { object TestProbeSpec {
val timeoutConfig = ConfigFactory.parseString(""" val timeoutConfig = ConfigFactory.parseString("""
akka.actor.testkit.typed.default-timeout = 100ms pekko.actor.testkit.typed.default-timeout = 100ms
akka.test.default-timeout = 100ms""") pekko.test.default-timeout = 100ms""")
/** Helper events for tests. */ /** Helper events for tests. */
final case class EventT(id: Long) 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( new AkkaJUnitActorSystemResource(
"JavaExtension", "JavaExtension",
ConfigFactory.parseString( ConfigFactory.parseString(
"akka.extensions = [ \"org.apache.pekko.actor.JavaExtension$TestExtensionId\" ]") "pekko.extensions = [ \"org.apache.pekko.actor.JavaExtension$TestExtensionId\" ]")
.withFallback(AkkaSpec.testConf())); .withFallback(AkkaSpec.testConf()));
private final ActorSystem system = actorSystemResource.getSystem(); 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() { public void mustBeAbleToUseUnrestrictedStash() {
testAStashApi( testAStashApi(
Props.create(StashJavaAPITestActors.WithUnrestrictedStash.class) 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 { 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 @Rule
public AkkaJUnitActorSystemResource actorSystemResource = 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 # for the org.apache.pekko.actor.ExtensionSpec
library-extensions += "org.apache.pekko.actor.InstanceCountingExtension" library-extensions += "org.apache.pekko.actor.InstanceCountingExtension"
} }
# FIXME Some test depend on this setting when running on windows. # FIXME Some test depend on this setting when running on windows.
# It should be removed when #17122 is solved. # 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" mailbox-type = "org.apache.pekko.actor.ActorMailboxSpec$$MCBoundedMailbox"
} }
akka.actor.deployment { pekko.actor.deployment {
/default-default { /default-default {
} }
/default-override-from-props { /default-override-from-props {
@ -110,10 +110,10 @@ object ActorMailboxSpec {
mailbox = bounded-mailbox-with-zero-pushtimeout mailbox = bounded-mailbox-with-zero-pushtimeout
} }
/default-unbounded-deque { /default-unbounded-deque {
mailbox = akka.actor.mailbox.unbounded-deque-based mailbox = pekko.actor.mailbox.unbounded-deque-based
} }
/default-unbounded-deque-override-trait { /default-unbounded-deque-override-trait {
mailbox = akka.actor.mailbox.unbounded-deque-based mailbox = pekko.actor.mailbox.unbounded-deque-based
} }
/unbounded-default { /unbounded-default {
dispatcher = unbounded-dispatcher dispatcher = unbounded-dispatcher
@ -138,20 +138,20 @@ object ActorMailboxSpec {
} }
/bounded-deque-requirements-configured { /bounded-deque-requirements-configured {
dispatcher = requiring-bounded-dispatcher dispatcher = requiring-bounded-dispatcher
mailbox = akka.actor.mailbox.bounded-deque-based mailbox = pekko.actor.mailbox.bounded-deque-based
} }
/bounded-deque-require-unbounded-configured { /bounded-deque-require-unbounded-configured {
dispatcher = requiring-bounded-dispatcher dispatcher = requiring-bounded-dispatcher
mailbox = akka.actor.mailbox.unbounded-deque-based mailbox = pekko.actor.mailbox.unbounded-deque-based
} }
/bounded-deque-require-unbounded-unconfigured { /bounded-deque-require-unbounded-unconfigured {
dispatcher = requiring-bounded-dispatcher dispatcher = requiring-bounded-dispatcher
} }
/bounded-deque-requirements-configured-props-disp { /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 { /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 { /bounded-deque-requirements-configured-props-mail {
dispatcher = requiring-bounded-dispatcher dispatcher = requiring-bounded-dispatcher
@ -164,7 +164,7 @@ object ActorMailboxSpec {
} }
} }
akka.actor.mailbox.requirements { pekko.actor.mailbox.requirements {
"org.apache.pekko.actor.ActorMailboxSpec$$MCBoundedMessageQueueSemantics" = "org.apache.pekko.actor.ActorMailboxSpec$$MCBoundedMessageQueueSemantics" =
mc-bounded-mailbox 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 { "get an unbounded deque message queue when it is only configured on the props" in {
checkMailboxQueue( checkMailboxQueue(
Props[QueueReportingActor]().withMailbox("akka.actor.mailbox.unbounded-deque-based"), Props[QueueReportingActor]().withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"default-override-from-props", "default-override-from-props",
UnboundedDeqMailboxTypes) 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 { "get an unbounded message queue overriding configuration on the props" in {
checkMailboxQueue( checkMailboxQueue(
Props[QueueReportingActor]().withMailbox("akka.actor.mailbox.unbounded-deque-based"), Props[QueueReportingActor]().withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"bounded-unbounded-override-props", "bounded-unbounded-override-props",
UnboundedMailboxTypes) UnboundedMailboxTypes)
} }
@ -366,7 +366,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
checkMailboxQueue( checkMailboxQueue(
Props[StashQueueReportingActor]() Props[StashQueueReportingActor]()
.withDispatcher("requiring-bounded-dispatcher") .withDispatcher("requiring-bounded-dispatcher")
.withMailbox("akka.actor.mailbox.bounded-deque-based"), .withMailbox("pekko.actor.mailbox.bounded-deque-based"),
"bounded-deque-requirements-configured-props", "bounded-deque-requirements-configured-props",
BoundedDeqMailboxTypes) BoundedDeqMailboxTypes)
} }
@ -376,7 +376,7 @@ class ActorMailboxSpec(conf: Config) extends AkkaSpec(conf) with DefaultTimeout
system.actorOf( system.actorOf(
Props[StashQueueReportingActor]() Props[StashQueueReportingActor]()
.withDispatcher("requiring-bounded-dispatcher") .withDispatcher("requiring-bounded-dispatcher")
.withMailbox("akka.actor.mailbox.unbounded-deque-based"), .withMailbox("pekko.actor.mailbox.unbounded-deque-based"),
"bounded-deque-require-unbounded-configured-props")) "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 { "get a bounded deque-based message queue if configured and required with Props (mailbox)" in {
checkMailboxQueue( 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", "bounded-deque-requirements-configured-props-mail",
BoundedDeqMailboxTypes) 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 { "fail with a unbounded deque-based message queue if configured and required with Props (mailbox)" in {
intercept[ConfigurationException]( intercept[ConfigurationException](
system.actorOf( 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")) "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(""" class ActorRefSpec extends AkkaSpec("""
# testing Java serialization of ActorRef # testing Java serialization of ActorRef
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
""") with DefaultTimeout { """) with DefaultTimeout {
import org.apache.pekko.actor.ActorRefSpec._ 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 ecProbe = TestProbe()
val ec = new SnitchingExecutionContext(ecProbe.ref, ExecutionContexts.global()) 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( val system2 = ActorSystem(
name = "ActorSystemDispatchersSpec-ec-configured", name = "ActorSystemDispatchersSpec-ec-configured",
config = Some(config), config = Some(config),
@ -97,13 +97,13 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
val sys = ActorSystem( val sys = ActorSystem(
"ActorSystemDispatchersSpec-override-internal-disp", "ActorSystemDispatchersSpec-override-internal-disp",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.actor.internal-dispatcher = akka.actor.default-dispatcher pekko.actor.internal-dispatcher = pekko.actor.default-dispatcher
""")) """))
try { try {
// that the user guardian runs on the overridden dispatcher instead of internal // 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 // 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 // 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 { } finally {
shutdown(sys) shutdown(sys)
} }
@ -118,7 +118,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
ActorSystem( ActorSystem(
name = "ActorSystemDispatchersSpec-passed-in-ec-for-internal", name = "ActorSystemDispatchersSpec-passed-in-ec-for-internal",
config = Some(ConfigFactory.parseString(""" config = Some(ConfigFactory.parseString("""
akka.actor.internal-dispatcher = akka.actor.default-dispatcher pekko.actor.internal-dispatcher = pekko.actor.default-dispatcher
""")), """)),
defaultExecutionContext = Some(ec)) defaultExecutionContext = Some(ec))
@ -141,7 +141,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
} }
"use an internal dispatcher for the guardian by default" in { "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 { "use the default dispatcher by a user provided user guardian" in {
@ -154,7 +154,7 @@ class ActorSystemDispatchersSpec extends AkkaSpec(ConfigFactory.parseString("""
ActorSystemSetup.empty) ActorSystemSetup.empty)
sys.start() sys.start()
try { try {
userGuardianDispatcher(sys) should ===("akka.actor.default-dispatcher") userGuardianDispatcher(sys) should ===("pekko.actor.default-dispatcher")
} finally shutdown(sys) } 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 { "log dead letters" in {
val sys = val sys =
ActorSystem("LogDeadLetters", ConfigFactory.parseString("akka.loglevel=INFO").withFallback(AkkaSpec.testConf)) ActorSystem("LogDeadLetters", ConfigFactory.parseString("pekko.loglevel=INFO").withFallback(AkkaSpec.testConf))
try { try {
val probe = TestProbe()(sys) val probe = TestProbe()(sys)
val a = sys.actorOf(Props[ActorSystemSpec.Terminater]()) 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 { "log dead letters sent without sender reference" in {
val sys = val sys =
ActorSystem("LogDeadLetters", ConfigFactory.parseString("akka.loglevel=INFO").withFallback(AkkaSpec.testConf)) ActorSystem("LogDeadLetters", ConfigFactory.parseString("pekko.loglevel=INFO").withFallback(AkkaSpec.testConf))
try { try {
val probe = TestProbe()(sys) val probe = TestProbe()(sys)
val a = sys.actorOf(Props[ActorSystemSpec.Terminater]()) val a = sys.actorOf(Props[ActorSystemSpec.Terminater]())
@ -317,7 +317,7 @@ class ActorSystemSpec extends AkkaSpec(ActorSystemSpec.config) with ImplicitSend
ActorSystem( ActorSystem(
"Stop", "Stop",
ConfigFactory 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)) .withFallback(AkkaSpec.testConf))
val a = system.actorOf(Props(new Actor { val a = system.actorOf(Props(new Actor {
def receive = { def receive = {
@ -340,7 +340,7 @@ class ActorSystemSpec extends AkkaSpec(ActorSystemSpec.config) with ImplicitSend
ActorSystem( ActorSystem(
"Stop", "Stop",
ConfigFactory 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)) .withFallback(AkkaSpec.testConf))
val a = system.actorOf(Props(new Actor { val a = system.actorOf(Props(new Actor {
def receive = { 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 = { def run(): Unit = {
// System.setProperty("akka.config", "akka.conf") // System.setProperty("pekko.config", "pekko.conf")
Chameneos.start = System.currentTimeMillis Chameneos.start = System.currentTimeMillis
val system = ActorSystem() val system = ActorSystem()
system.actorOf(Props(new Mall(1000000, 4))) 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 class CoordinatedShutdownSpec
extends AkkaSpec(ConfigFactory.parseString(""" extends AkkaSpec(ConfigFactory.parseString("""
akka.loglevel=INFO pekko.loglevel=INFO
akka.loggers = ["org.apache.pekko.testkit.TestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.TestEventListener"]
""")) { """)) {
def extSys = system.asInstanceOf[ExtendedActorSystem] def extSys = system.asInstanceOf[ExtendedActorSystem]
@ -511,13 +511,13 @@ class CoordinatedShutdownSpec
} }
"default exit code to 0" in { "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) val confWithOverrides = CoordinatedShutdown.confWithOverrides(conf, None)
confWithOverrides.getInt("exit-code") should ===(0) confWithOverrides.getInt("exit-code") should ===(0)
} }
"default exit code to -1 when the Reason is ClusterDowning" in { "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 = val confWithOverrides =
CoordinatedShutdown.confWithOverrides(conf, Some(CoordinatedShutdown.ClusterDowningReason)) CoordinatedShutdown.confWithOverrides(conf, Some(CoordinatedShutdown.ClusterDowningReason))
confWithOverrides.getInt("exit-code") should ===(-1) confWithOverrides.getInt("exit-code") should ===(-1)
@ -549,7 +549,7 @@ class CoordinatedShutdownSpec
val sys = ActorSystem( val sys = ActorSystem(
system.name, system.name,
ConfigFactory 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)) .withFallback(system.settings.config))
try { try {
Await.result(sys.terminate(), 10.seconds) Await.result(sys.terminate(), 10.seconds)
@ -565,7 +565,7 @@ class CoordinatedShutdownSpec
val sys = ActorSystem( val sys = ActorSystem(
system.name, system.name,
ConfigFactory ConfigFactory
.parseString("akka.coordinated-shutdown.terminate-actor-system = off") .parseString("pekko.coordinated-shutdown.terminate-actor-system = off")
.withFallback(system.settings.config)) .withFallback(system.settings.config))
// will only get here if test is failing // will only get here if test is failing
shutdown(sys) 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 { "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 systemName = s"CoordinatedShutdownSpec-JvmHooks-1-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString(""" lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = off pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = off
akka.coordinated-shutdown.terminate-actor-system = off pekko.coordinated-shutdown.terminate-actor-system = off
akka.coordinated-shutdown.run-by-actor-system-terminate = off pekko.coordinated-shutdown.run-by-actor-system-terminate = off
""") """)
override def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = { 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 { "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 systemName = s"CoordinatedShutdownSpec-JvmHooks-2-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString(""" lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
akka.coordinated-shutdown.terminate-actor-system = off pekko.coordinated-shutdown.terminate-actor-system = off
akka.coordinated-shutdown.run-by-actor-system-terminate = off pekko.coordinated-shutdown.run-by-actor-system-terminate = off
""") """)
override def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = { 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 { "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 systemName = s"CoordinatedShutdownSpec-JvmHooks-3-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString(""" lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
akka.coordinated-shutdown.terminate-actor-system = on pekko.coordinated-shutdown.terminate-actor-system = on
""") """)
def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = { 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 systemName = s"CoordinatedShutdownSpec-JvmHooks-4-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString(""" lazy val systemConfig = ConfigFactory.parseString("""
akka.jvm-shutdown-hooks = off pekko.jvm-shutdown-hooks = off
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
""") """)
def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = { def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -638,8 +638,8 @@ class CoordinatedShutdownSpec
"access extension after system termination" in new JvmHookTest { "access extension after system termination" in new JvmHookTest {
lazy val systemName = s"CoordinatedShutdownSpec-terminated-${System.currentTimeMillis()}" lazy val systemName = s"CoordinatedShutdownSpec-terminated-${System.currentTimeMillis()}"
lazy val systemConfig = ConfigFactory.parseString(""" lazy val systemConfig = ConfigFactory.parseString("""
akka.coordinated-shutdown.run-by-jvm-shutdown-hook = on pekko.coordinated-shutdown.run-by-jvm-shutdown-hook = on
akka.coordinated-shutdown.terminate-actor-system = on pekko.coordinated-shutdown.terminate-actor-system = on
""") """)
def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = { def withSystemRunning(newSystem: ActorSystem, coordinatedShutdown: CoordinatedShutdown): Unit = {
@ -653,7 +653,7 @@ class CoordinatedShutdownSpec
val system = ActorSystem( val system = ActorSystem(
s"CoordinatedShutdownSpec-terminated-${System.currentTimeMillis()}", s"CoordinatedShutdownSpec-terminated-${System.currentTimeMillis()}",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.coordinated-shutdown.phases { pekko.coordinated-shutdown.phases {
before-actor-system-terminate { before-actor-system-terminate {
} }
@ -780,7 +780,7 @@ class CoordinatedShutdownSpec
} else false } 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 // pretend extension creation and start
private val cs = new CoordinatedShutdown(newSystem, CoordinatedShutdown.phasesFromConfig(csConfig), mockRuntime) private val cs = new CoordinatedShutdown(newSystem, CoordinatedShutdown.phasesFromConfig(csConfig), mockRuntime)
CoordinatedShutdown.init(newSystem, csConfig, cs) 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(""" class DeadLetterSuspensionSpec extends AkkaSpec("""
akka.loglevel = INFO pekko.loglevel = INFO
akka.log-dead-letters = 4 pekko.log-dead-letters = 4
akka.log-dead-letters-suspend-duration = 2s pekko.log-dead-letters-suspend-duration = 2s
""") with ImplicitSender { """) with ImplicitSender {
import DeadLetterSuspensionSpec._ import DeadLetterSuspensionSpec._
@ -58,7 +58,7 @@ class DeadLetterSuspensionSpec extends AkkaSpec("""
private def expectedUnhandledLogMessage(count: Int): String = private def expectedUnhandledLogMessage(count: Int): String =
s"Message [java.lang.Integer] from $testActor to $unhandledActor was unhandled. [$count] dead letters encountered" 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 { EventFilter.info(start = expectedDeadLettersLogMessage(1), occurrences = 1).intercept {
deadActor ! 1 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 { object DeployerSpec {
val deployerConf = ConfigFactory.parseString( val deployerConf = ConfigFactory.parseString(
""" """
akka.actor.deployment { pekko.actor.deployment {
/service1 { /service1 {
} }
/service-direct { /service-direct {
@ -82,7 +82,7 @@ object DeployerSpec {
class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) { class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
"A Deployer" must { "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 service = "/service1"
val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1)) 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) 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 service = "/service3"
val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1)) val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
@ -118,7 +118,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
Deploy.NoMailboxGiven))) 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 service = "/service4"
val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1)) 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 val invalidDeployerConf = ConfigFactory
.parseString( .parseString(
""" """
akka.actor.deployment { pekko.actor.deployment {
/service-invalid-number-of-instances { /service-invalid-number-of-instances {
router = round-robin-pool router = round-robin-pool
nr-of-instances = boom nr-of-instances = boom
@ -157,7 +157,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
val invalidDeployerConf = ConfigFactory val invalidDeployerConf = ConfigFactory
.parseString( .parseString(
""" """
akka.actor.deployment { pekko.actor.deployment {
/gul/ubåt { /gul/ubåt {
router = round-robin-pool router = round-robin-pool
nr-of-instances = 2 nr-of-instances = 2
@ -173,7 +173,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
e.getMessage should include("[/gul/ubåt]") 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") assertRouting("/service-direct", NoRouter, "/service-direct")
} }
@ -181,26 +181,26 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
assertRouting("/service-direct2", NoRouter, "/service-direct2") 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") 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") 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( assertRouting(
"/service-scatter-gather", "/service-scatter-gather",
ScatterGatherFirstCompletedPool(nrOfInstances = 1, within = 2 seconds), ScatterGatherFirstCompletedPool(nrOfInstances = 1, within = 2 seconds),
"/service-scatter-gather") "/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") 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() val resizer = DefaultResizer()
assertRouting("/service-resizer", RoundRobinPool(nrOfInstances = 0, resizer = Some(resizer)), "/service-resizer") 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 { "The ActorSystem extensions support" should {
"support extensions" in { "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) val system = ActorSystem("extensions", config)
// TestExtension is configured and should be loaded at startup // TestExtension is configured and should be loaded at startup
@ -87,23 +87,23 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
shutdownActorSystem(system) 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] { intercept[RuntimeException] {
val system = ActorSystem( val system = ActorSystem(
"failing", "failing",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.extensions = ["org.apache.pekko.actor.FailingTestExtension"] pekko.extensions = ["org.apache.pekko.actor.FailingTestExtension"]
""")) """))
shutdownActorSystem(system) 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( val system = ActorSystem(
"failing", "failing",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.extensions = ["org.apache.pekko.actor.MissingExtension"] pekko.extensions = ["org.apache.pekko.actor.MissingExtension"]
""")) """))
EventFilter.error( EventFilter.error(
"While trying to load extension [org.apache.pekko.actor.MissingExtension], skipping.").intercept(())(system) "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 // could be initialized by other tests, but assuming tests are not running in parallel
val countBefore = InstanceCountingExtension.createCount.get() val countBefore = InstanceCountingExtension.createCount.get()
val system = ActorSystem("extensions") 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) listedExtensions.count(_.contains("InstanceCountingExtension")) should ===(1)
InstanceCountingExtension.createCount.get() - countBefore should ===(1) InstanceCountingExtension.createCount.get() - countBefore should ===(1)
@ -131,9 +131,9 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
"extensions", "extensions",
ConfigFactory.parseString( 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 listedExtensions.count(_.contains("InstanceCountingExtension")) should ===(3) // testing duplicate names
InstanceCountingExtension.createCount.get() - countBefore should ===(1) InstanceCountingExtension.createCount.get() - countBefore should ===(1)
@ -146,7 +146,7 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
ActorSystem( ActorSystem(
"failing", "failing",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.library-extensions += "org.apache.pekko.actor.FailingTestExtension" pekko.library-extensions += "org.apache.pekko.actor.FailingTestExtension"
""").withFallback(ConfigFactory.load()).resolve()) """).withFallback(ConfigFactory.load()).resolve())
} }
@ -157,7 +157,7 @@ class ExtensionSpec extends AnyWordSpec with Matchers {
ActorSystem( ActorSystem(
"failing", "failing",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.library-extensions += "org.apache.pekko.actor.MissingExtension" pekko.library-extensions += "org.apache.pekko.actor.MissingExtension"
""").withFallback(ConfigFactory.load())) """).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) 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._ import FSMActorSpec._
val timeout = Timeout(2 seconds) 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 { "log events and transitions if asked to do so" in {
import pekko.util.ccompat.JavaConverters._ import pekko.util.ccompat.JavaConverters._
val config = ConfigFactory 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) .withFallback(system.settings.config)
val fsmEventSystem = ActorSystem("fsmEvent", config) val fsmEventSystem = ActorSystem("fsmEvent", config)
try { 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(""" class FunctionRefSpec extends AkkaSpec("""
# test is using Java serialization and relies on serialize-messages=on # test is using Java serialization and relies on serialize-messages=on
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = off pekko.actor.warn-about-java-serializer-usage = off
akka.actor.serialize-messages = on pekko.actor.serialize-messages = on
akka.actor.no-serialization-verification-needed-class-prefix = [] pekko.actor.no-serialization-verification-needed-class-prefix = []
""") with ImplicitSender { """) with ImplicitSender {
import FunctionRefSpec._ 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 { object LocalActorRefProviderSpec {
val config = """ val config = """
akka { pekko {
log-dead-letters = on log-dead-letters = on
actor { actor {
debug.unhandled = on 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(""" class PropsCreationSpec extends AkkaSpec("""
# test is using Java serialization and relies on serialize-creators=on # test is using Java serialization and relies on serialize-creators=on
akka.actor.serialize-creators = on pekko.actor.serialize-creators = on
akka.actor.no-serialization-verification-needed-class-prefix = [] pekko.actor.no-serialization-verification-needed-class-prefix = []
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = off pekko.actor.warn-about-java-serializer-usage = off
""") { """) {
import org.apache.pekko.actor.PropsCreationSpec._ 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() val classLoader = findClassLoader()
def settingsWith(key: String): Settings = { 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) 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 { object SchedulerSpec {
val testConfRevolver = val testConfRevolver =
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.scheduler.implementation = org.apache.pekko.actor.LightArrayRevolverScheduler pekko.scheduler.implementation = org.apache.pekko.actor.LightArrayRevolverScheduler
akka.scheduler.ticks-per-wheel = 32 pekko.scheduler.ticks-per-wheel = 32
""").withFallback(AkkaSpec.testConf) """).withFallback(AkkaSpec.testConf)
} }
@ -473,7 +473,7 @@ class LightArrayRevolverSchedulerSpec extends AkkaSpec(SchedulerSpec.testConfRev
} }
"survive vicious enqueueing" taggedAs TimingTest in { "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 driver._
import system.dispatcher import system.dispatcher
val counter = new AtomicInteger val counter = new AtomicInteger
@ -533,7 +533,7 @@ class LightArrayRevolverSchedulerSpec extends AkkaSpec(SchedulerSpec.testConfRev
} }
"correctly wrap around wheel rounds" taggedAs TimingTest in { "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 implicit def ec: ExecutionContext = localEC
import driver._ import driver._
val start = step / 2 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 { hierarchy {
type = "org.apache.pekko.actor.SupervisorHierarchySpec$MyDispatcherConfigurator" type = "org.apache.pekko.actor.SupervisorHierarchySpec$MyDispatcherConfigurator"
} }
akka.loglevel = INFO pekko.loglevel = INFO
akka.actor.debug.fsm = on pekko.actor.debug.fsm = on
""") """)
class MyDispatcherConfigurator(config: Config, prerequisites: DispatcherPrerequisites) 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 fixed-pool-size = 60
} }
} }
akka.actor.serializers.sample = "org.apache.pekko.actor.TypedActorSpec$SampleSerializerWithStringManifest$" pekko.actor.serializers.sample = "org.apache.pekko.actor.TypedActorSpec$SampleSerializerWithStringManifest$"
akka.actor.serialization-bindings."org.apache.pekko.actor.TypedActorSpec$WithStringSerializedClass" = sample pekko.actor.serialization-bindings."org.apache.pekko.actor.TypedActorSpec$WithStringSerializedClass" = sample
# test is using Java serialization and not priority to convert # test is using Java serialization and not priority to convert
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = off pekko.actor.warn-about-java-serializer-usage = off
""" """
class CyclicIterator[T](val items: immutable.Seq[T]) extends Iterator[T] { 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 my-aliased-dispatcher = myapp.mydispatcher
missing-aliased-dispatcher = myapp.missing-dispatcher missing-aliased-dispatcher = myapp.missing-dispatcher
} }
akka.actor.deployment { pekko.actor.deployment {
/echo1 { /echo1 {
dispatcher = myapp.mydispatcher dispatcher = myapp.mydispatcher
} }
@ -123,7 +123,7 @@ class DispatchersSpec extends AkkaSpec(DispatchersSpec.config) with ImplicitSend
def validTypes = typesAndValidators.keys.toList 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] = { lazy val allDispatchers: Map[String, MessageDispatcher] = {
import pekko.util.ccompat.JavaConverters._ 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 { "include system name and dispatcher id in thread names for default-dispatcher" in {
system.actorOf(Props[ThreadNameEcho]()) ! "what's the name?" 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() { expectMsgPF() {
case Expected(_) => case Expected(_) =>
} }
@ -268,7 +268,7 @@ class DispatchersSpec extends AkkaSpec(DispatchersSpec.config) with ImplicitSend
pool ! Identify(None) pool ! Identify(None)
val routee = expectMsgType[ActorIdentity].ref.get val routee = expectMsgType[ActorIdentity].ref.get
routee ! "what's the name?" 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() { expectMsgPF() {
case Expected(_) => 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(""" class DispatchSpec extends AkkaSpec("""
akka.actor.serialize-messages = on pekko.actor.serialize-messages = on
akka.actor.no-serialization-verification-needed-class-prefix = [] pekko.actor.no-serialization-verification-needed-class-prefix = []
""") with DefaultTimeout { """) with DefaultTimeout {
import DispatchSpec._ import DispatchSpec._
"The dispatcher" should { "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]()) val actor = system.actorOf(Props[EmptyActor]())
EventFilter[Exception](pattern = ".*NoSerializationVerificationNeeded.*", occurrences = 1).intercept { EventFilter[Exception](pattern = ".*NoSerializationVerificationNeeded.*", occurrences = 1).intercept {
actor ! new UnserializableMessageClass 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._ import config._
getString("akka.version") should ===(ActorSystem.Version) getString("pekko.version") should ===(ActorSystem.Version)
settings.ConfigVersion 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.SerializeAllMessages should ===(false)
settings.NoSerializationVerificationNeededClassPrefix should ===(Set("org.apache.pekko.")) settings.NoSerializationVerificationNeededClassPrefix should ===(Set("org.apache.pekko."))
getInt("akka.scheduler.ticks-per-wheel") should ===(512) getInt("pekko.scheduler.ticks-per-wheel") should ===(512)
getDuration("akka.scheduler.tick-duration", TimeUnit.MILLISECONDS) should ===(10L) getDuration("pekko.scheduler.tick-duration", TimeUnit.MILLISECONDS) should ===(10L)
getString("akka.scheduler.implementation") should ===("org.apache.pekko.actor.LightArrayRevolverScheduler") getString("pekko.scheduler.implementation") should ===("org.apache.pekko.actor.LightArrayRevolverScheduler")
getBoolean("akka.daemonic") should ===(false) getBoolean("pekko.daemonic") should ===(false)
settings.Daemonicity 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.JvmExitOnFatalError should ===(true)
settings.JvmShutdownHooks should ===(true) settings.JvmShutdownHooks should ===(true)
getBoolean("akka.fail-mixed-versions") should ===(true) getBoolean("pekko.fail-mixed-versions") should ===(true)
settings.FailMixedVersions 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) 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.UnstartedPushTimeout.duration should ===(10.seconds)
settings.Loggers.size should ===(1) settings.Loggers.size should ===(1)
settings.Loggers.head should ===(classOf[DefaultLogger].getName) 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) 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) 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) 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) 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) 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) settings.CoordinatedShutdownRunByActorSystemTerminate should ===(true)
getBoolean("akka.actor.allow-java-serialization") should ===(false) getBoolean("pekko.actor.allow-java-serialization") should ===(false)
settings.AllowJavaSerialization 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 // General dispatcher config
@ -133,7 +133,7 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
// Debug config // Debug config
{ {
val debug = config.getConfig("akka.actor.debug") val debug = config.getConfig("pekko.actor.debug")
import debug._ import debug._
getBoolean("receive") should ===(false) getBoolean("receive") should ===(false)
settings.AddLoggingReceive 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 // 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 { "not be amended for default reference in akka-actor" in {
val dynamicAccess = system.asInstanceOf[ExtendedActorSystem].dynamicAccess val dynamicAccess = system.asInstanceOf[ExtendedActorSystem].dynamicAccess
val config = ActorSystem.Settings.amendSlf4jConfig(ConfigFactory.defaultReference(), dynamicAccess) val config = ActorSystem.Settings.amendSlf4jConfig(ConfigFactory.defaultReference(), dynamicAccess)
config.getStringList("akka.loggers").size() should ===(1) config.getStringList("pekko.loggers").size() should ===(1)
config.getStringList("akka.loggers").get(0) should ===(classOf[DefaultLogger].getName) config.getStringList("pekko.loggers").get(0) should ===(classOf[DefaultLogger].getName)
config.getString("akka.logging-filter") should ===(classOf[DefaultLoggingFilter].getName) config.getString("pekko.logging-filter") should ===(classOf[DefaultLoggingFilter].getName)
} }
"not be amended when akka-slf4j is not in classpath" in { "not be amended when akka-slf4j is not in classpath" in {
val dynamicAccess = system.asInstanceOf[ExtendedActorSystem].dynamicAccess val dynamicAccess = system.asInstanceOf[ExtendedActorSystem].dynamicAccess
val config = ActorSystem.Settings.amendSlf4jConfig( val config = ActorSystem.Settings.amendSlf4jConfig(
ConfigFactory.parseString("akka.use-slf4j = on").withFallback(ConfigFactory.defaultReference()), ConfigFactory.parseString("pekko.use-slf4j = on").withFallback(ConfigFactory.defaultReference()),
dynamicAccess) dynamicAccess)
config.getStringList("akka.loggers").size() should ===(1) config.getStringList("pekko.loggers").size() should ===(1)
config.getStringList("akka.loggers").get(0) should ===(classOf[DefaultLogger].getName) config.getStringList("pekko.loggers").get(0) should ===(classOf[DefaultLogger].getName)
config.getString("akka.logging-filter") should ===(classOf[DefaultLoggingFilter].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 .toList
.map(_.getThreadName) .map(_.getThreadName)
.filter(name => .filter(name =>
name.startsWith("DispatcherShutdownSpec-akka.actor.default") || name.startsWith( name.startsWith("DispatcherShutdownSpec-pekko.actor.default") || name.startsWith(
"DispatcherShutdownSpec-akka.actor.internal")) // nothing is run on default without any user actors started "DispatcherShutdownSpec-pekko.actor.internal")) // nothing is run on default without any user actors started
.size .size
val system = ActorSystem("DispatcherShutdownSpec") 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._ import AddressTerminatedTopicBenchSpec._
"Subscribe and unsubscribe of AddressTerminated" must { "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._ import org.apache.pekko.event.ActorEventBusSpec._
def this() = 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 type BusType = MyActorEventBus
def createNewEventBus(): BusType = new MyActorEventBus(system) 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 { object EventStreamSpec {
val config = ConfigFactory.parseString(""" val config = ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = WARNING stdout-loglevel = WARNING
loglevel = INFO loglevel = INFO
loggers = ["org.apache.pekko.event.EventStreamSpec$MyLog", "%s"] loggers = ["org.apache.pekko.event.EventStreamSpec$MyLog", "%s"]
@ -23,7 +23,7 @@ object EventStreamSpec {
""".format(Logging.StandardOutLogger.getClass.getName)) """.format(Logging.StandardOutLogger.getClass.getName))
val configUnhandled = ConfigFactory.parseString(""" val configUnhandled = ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = WARNING stdout-loglevel = WARNING
loglevel = WARNING loglevel = WARNING
actor.debug.unhandled = on actor.debug.unhandled = on
@ -32,7 +32,7 @@ object EventStreamSpec {
""") """)
val configUnhandledWithDebug = 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) 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 { object LoggerSpec {
val defaultConfig = ConfigFactory.parseString(""" val defaultConfig = ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = "WARNING" stdout-loglevel = "WARNING"
loglevel = "DEBUG" # test verifies debug loglevel = "DEBUG" # test verifies debug
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"] loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"]
@ -37,7 +37,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf) """).withFallback(AkkaSpec.testConf)
val slowConfig = ConfigFactory.parseString(""" val slowConfig = ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = "ERROR" stdout-loglevel = "ERROR"
loglevel = "ERROR" loglevel = "ERROR"
loggers = ["org.apache.pekko.event.LoggerSpec$SlowLogger"] loggers = ["org.apache.pekko.event.LoggerSpec$SlowLogger"]
@ -45,7 +45,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf) """).withFallback(AkkaSpec.testConf)
val noLoggingConfig = ConfigFactory.parseString(""" val noLoggingConfig = ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = "OFF" stdout-loglevel = "OFF"
loglevel = "OFF" loglevel = "OFF"
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"] loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"]
@ -54,7 +54,7 @@ object LoggerSpec {
val multipleConfig = val multipleConfig =
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = "OFF" stdout-loglevel = "OFF"
loglevel = "WARNING" loglevel = "WARNING"
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1", "org.apache.pekko.event.LoggerSpec$TestLogger2"] loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1", "org.apache.pekko.event.LoggerSpec$TestLogger2"]
@ -62,7 +62,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf) """).withFallback(AkkaSpec.testConf)
val ticket3165Config = ConfigFactory.parseString(s""" val ticket3165Config = ConfigFactory.parseString(s"""
akka { pekko {
stdout-loglevel = "WARNING" stdout-loglevel = "WARNING"
loglevel = "DEBUG" # test verifies debug loglevel = "DEBUG" # test verifies debug
loggers = ["org.apache.pekko.event.LoggerSpec$$TestLogger1"] loggers = ["org.apache.pekko.event.LoggerSpec$$TestLogger1"]
@ -78,7 +78,7 @@ object LoggerSpec {
""").withFallback(AkkaSpec.testConf) """).withFallback(AkkaSpec.testConf)
val ticket3671Config = ConfigFactory.parseString(""" val ticket3671Config = ConfigFactory.parseString("""
akka { pekko {
stdout-loglevel = "WARNING" stdout-loglevel = "WARNING"
loglevel = "WARNING" loglevel = "WARNING"
loggers = ["org.apache.pekko.event.LoggerSpec$TestLogger1"] 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._ import LoggingReceiveSpec._
val config = ConfigFactory.parseString(""" val config = ConfigFactory.parseString("""
akka.loglevel=DEBUG # test verifies debug pekko.loglevel=DEBUG # test verifies debug
""").withFallback(AkkaSpec.testConf) """).withFallback(AkkaSpec.testConf)
val appLogging = 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( val appAuto = ActorSystem(
"autoreceive", "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( val appLifecycle = ActorSystem(
"lifecycle", "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 { val filter = TestEvent.Mute(EventFilter.custom {
case _: Logging.Debug => true 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 { object JavaLoggerSpec {
val config = ConfigFactory.parseString(""" val config = ConfigFactory.parseString("""
akka { pekko {
loglevel = INFO loglevel = INFO
loggers = ["org.apache.pekko.event.jul.JavaLogger"] loggers = ["org.apache.pekko.event.jul.JavaLogger"]
logging-filter = "org.apache.pekko.event.jul.JavaLoggingFilter" 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 import pekko.testkit.SocketUtil.temporaryServerAddresses
class CapacityLimitSpec extends AkkaSpec(""" class CapacityLimitSpec extends AkkaSpec("""
akka.loglevel = ERROR pekko.loglevel = ERROR
akka.io.tcp.max-channels = 4 pekko.io.tcp.max-channels = 4
""") with TcpIntegrationSpecSupport { """) with TcpIntegrationSpecSupport {
"The TCP transport implementation" should { "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 @nowarn
class InetAddressDnsResolverSpec extends AkkaSpec(""" class InetAddressDnsResolverSpec extends AkkaSpec("""
akka.io.dns.inet-address.positive-ttl = default pekko.io.dns.inet-address.positive-ttl = default
akka.io.dns.inet-address.negative-ttl = default pekko.io.dns.inet-address.negative-ttl = default
""") { thisSpecs => """) { thisSpecs =>
"The DNS resolver default ttl's" must { "The DNS resolver default ttl's" must {
@ -95,7 +95,7 @@ class InetAddressDnsResolverSpec extends AkkaSpec("""
Props( Props(
classOf[InetAddressDnsResolver], classOf[InetAddressDnsResolver],
new SimpleDnsCache(), new SimpleDnsCache(),
system.settings.config.getConfig("akka.io.dns.inet-address"))) system.settings.config.getConfig("pekko.io.dns.inet-address")))
actorRef.underlyingActor actorRef.underlyingActor
} }
@ -123,8 +123,8 @@ class InetAddressDnsResolverSpec extends AkkaSpec("""
@nowarn @nowarn
class InetAddressDnsResolverConfigSpec extends AkkaSpec(""" class InetAddressDnsResolverConfigSpec extends AkkaSpec("""
akka.io.dns.inet-address.positive-ttl = forever pekko.io.dns.inet-address.positive-ttl = forever
akka.io.dns.inet-address.negative-ttl = never pekko.io.dns.inet-address.negative-ttl = never
""") { """) {
thisSpecs => thisSpecs =>
@ -144,7 +144,7 @@ class InetAddressDnsResolverConfigSpec extends AkkaSpec("""
Props( Props(
classOf[InetAddressDnsResolver], classOf[InetAddressDnsResolver],
new SimpleDnsCache(), new SimpleDnsCache(),
system.settings.config.getConfig("akka.io.dns.inet-address"))) system.settings.config.getConfig("pekko.io.dns.inet-address")))
actorRef.underlyingActor 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(""" class TcpConnectionSpec extends AkkaSpec("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.tcp.trace-logging = on pekko.io.tcp.trace-logging = on
akka.io.tcp.register-timeout = 500ms pekko.io.tcp.register-timeout = 500ms
""") with WithLogCapturing { thisSpecs => """) with WithLogCapturing { thisSpecs =>
import TcpConnectionSpec._ import TcpConnectionSpec._
@ -377,7 +377,7 @@ class TcpConnectionSpec extends AkkaSpec("""
"respect pull mode" in new EstablishedConnectionTest(pullMode = true) { "respect pull mode" in new EstablishedConnectionTest(pullMode = true) {
// override config to decrease default buffer size // override config to decrease default buffer size
def config = 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) override implicit lazy val system: ActorSystem = ActorSystem("respectPullModeTest", config)
try run { 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 import pekko.util.ByteString
class TcpIntegrationSpec extends AkkaSpec(""" class TcpIntegrationSpec extends AkkaSpec("""
akka.loglevel = debug pekko.loglevel = debug
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.tcp.trace-logging = on pekko.io.tcp.trace-logging = on
""") with TcpIntegrationSpecSupport with TimeLimits with WithLogCapturing { """) with TcpIntegrationSpecSupport with TimeLimits with WithLogCapturing {
def verifyActorTermination(actor: ActorRef): Unit = { 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 import pekko.testkit.SocketUtil
class TcpListenerSpec extends AkkaSpec(""" class TcpListenerSpec extends AkkaSpec("""
akka.io.tcp.batch-accept-limit = 2 pekko.io.tcp.batch-accept-limit = 2
""") { """) {
"A TcpListener" must { "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 import pekko.util.ByteString
class UdpConnectedIntegrationSpec extends AkkaSpec(""" class UdpConnectedIntegrationSpec extends AkkaSpec("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.actor.debug.lifecycle = on pekko.actor.debug.lifecycle = on
akka.actor.debug.autoreceive = on pekko.actor.debug.autoreceive = on
akka.io.udp-connected.trace-logging = on pekko.io.udp-connected.trace-logging = on
# issues with dns resolution of non existent host hanging with the # issues with dns resolution of non existent host hanging with the
# Java native host resolution # Java native host resolution
akka.io.dns.resolver = async-dns pekko.io.dns.resolver = async-dns
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with ImplicitSender with WithLogCapturing { """) with ImplicitSender with WithLogCapturing {
val addresses = temporaryServerAddresses(5, udp = true) 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 import pekko.util.ByteString
class UdpIntegrationSpec extends AkkaSpec(""" class UdpIntegrationSpec extends AkkaSpec("""
akka.loglevel = INFO pekko.loglevel = INFO
# tests expect to be able to mutate messages # tests expect to be able to mutate messages
""") with ImplicitSender { """) 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) lazy val dockerDnsServerPort: Int = SocketUtil.temporaryLocalPort(Both)
implicit val defaultTimeout: Timeout = Timeout(10.seconds) implicit val defaultTimeout: Timeout = Timeout(10.seconds)
def conf = ConfigFactory.parseString(s""" def conf = ConfigFactory.parseString(s"""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.dns.resolver = async-dns pekko.io.dns.resolver = async-dns
akka.io.dns.async-dns.nameservers = ["localhost:${dockerDnsServerPort}"] pekko.io.dns.async-dns.nameservers = ["localhost:${dockerDnsServerPort}"]
akka.io.dns.async-dns.search-domains = ["foo.test", "test"] pekko.io.dns.async-dns.search-domains = ["foo.test", "test"]
akka.io.dns.async-dns.ndots = 2 pekko.io.dns.async-dns.ndots = 2
akka.io.dns.async-dns.resolve-timeout = ${defaultTimeout.duration.toSeconds}s 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 // tests deprecated DNS API
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
class AsyncDnsManagerSpec extends AkkaSpec(""" class AsyncDnsManagerSpec extends AkkaSpec("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
akka.io.dns.resolver = async-dns pekko.io.dns.resolver = async-dns
akka.io.dns.async-dns.nameservers = default pekko.io.dns.async-dns.nameservers = default
""") with ImplicitSender with WithLogCapturing { """) with ImplicitSender with WithLogCapturing {
val dns = Dns(system).manager 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 } import pekko.testkit.{ AkkaSpec, TestProbe, WithLogCapturing }
class AsyncDnsResolverSpec extends AkkaSpec(""" class AsyncDnsResolverSpec extends AkkaSpec("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with WithLogCapturing { """) with WithLogCapturing {
val defaultConfig = ConfigFactory.parseString(""" 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 { class DnsClientSpec extends AkkaSpec with ImplicitSender {
"The async DNS client" should { "The async DNS client" should {
val exampleRequest = Question4(42, "akka.io") val exampleRequest = Question4(42, "pekko.io")
val exampleRequestMessage = 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 exampleResponseMessage = Message(42, MessageFlags(answer = true))
val exampleResponse = Answer(42, Nil) val exampleResponse = Answer(42, Nil)
val dnsServerAddress = InetSocketAddress.createUnresolved("foo", 53) 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 { "The async TCP DNS client" should {
val exampleRequestMessage = 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 exampleResponseMessage = Message(42, MessageFlags(answer = true))
val dnsServerAddress = InetSocketAddress.createUnresolved("foo", 53) val dnsServerAddress = InetSocketAddress.createUnresolved("foo", 53)
val localAddress = InetSocketAddress.createUnresolved("localhost", 13441) 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 @nowarn
class AskSpec extends AkkaSpec(""" class AskSpec extends AkkaSpec("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with WithLogCapturing { """) with WithLogCapturing {
"The “ask” pattern" must { "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(""" class BackoffOnRestartSupervisorSpec extends AkkaSpec("""
akka.loglevel = DEBUG pekko.loglevel = DEBUG
akka.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"] pekko.loggers = ["org.apache.pekko.testkit.SilenceAllTestEventListener"]
""") with WithLogCapturing with ImplicitSender { """) with WithLogCapturing with ImplicitSender {
def supervisorProps(probeRef: ActorRef) = { 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(""" class CircuitBreakerSpec extends AkkaSpec("""
akka.circuit-breaker { pekko.circuit-breaker {
identified { identified {
max-failures = 1 max-failures = 1
call-timeout = 100 ms 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(""" class BalancingSpec extends AkkaSpec("""
akka.loglevel=debug pekko.loglevel=debug
akka.actor.deployment { pekko.actor.deployment {
/balancingPool-2 { /balancingPool-2 {
router = balancing-pool router = balancing-pool
nr-of-instances = 5 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 { object ConfiguredLocalRoutingSpec {
val config = """ val config = """
akka { pekko {
actor { actor {
default-dispatcher { default-dispatcher {
executor = "thread-pool-executor" 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 { object ConsistentHashingRouterSpec {
val config = """ val config = """
akka.actor { pekko.actor {
# consistent hashing is serializing the hash key, unless it's bytes or string # consistent hashing is serializing the hash key, unless it's bytes or string
allow-java-serialization = on allow-java-serialization = on
} }
akka.actor.deployment { pekko.actor.deployment {
/router1 { /router1 {
router = consistent-hashing-pool router = consistent-hashing-pool
nr-of-instances = 3 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 { object ResizerSpec {
val config = """ val config = """
akka.actor.deployment { pekko.actor.deployment {
/router1 { /router1 {
router = round-robin-pool router = round-robin-pool
resizer { resizer {
@ -53,7 +53,7 @@ class ResizerSpec extends AkkaSpec(ResizerSpec.config) with DefaultTimeout with
"Resizer fromConfig" must { "Resizer fromConfig" must {
def parseCfg(cfgString: String): Config = { def parseCfg(cfgString: String): Config = {
val referenceCfg = ConfigFactory.defaultReference(ActorSystem.findClassLoader()) 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 { "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 { object RoutingSpec {
val config = """ val config = """
akka.actor.deployment { pekko.actor.deployment {
/router1 { /router1 {
router = round-robin-pool router = round-robin-pool
nr-of-instances = 3 nr-of-instances = 3
@ -239,7 +239,7 @@ class RoutingSpec extends AkkaSpec(RoutingSpec.config) with DefaultTimeout with
val sys = ActorSystem( val sys = ActorSystem(
"FromConfig", "FromConfig",
ConfigFactory ConfigFactory
.parseString("akka.actor.deployment./routed.router=round-robin-pool") .parseString("pekko.actor.deployment./routed.router=round-robin-pool")
.withFallback(system.settings.config)) .withFallback(system.settings.config))
try { try {
sys.actorOf(FromConfig.props(routeeProps = Props[TestActor]()), "routed") 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) case class Message4(str: String)
val config = ConfigFactory.parseString(s""" val config = ConfigFactory.parseString(s"""
akka { pekko {
actor { actor {
serializers { serializers {
async = "org.apache.pekko.serialization.AsyncSerializeSpec$$TestAsyncSerializer" 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(""" class DisabledJavaSerializerWarningSpec extends AkkaSpec("""
akka.actor { pekko.actor {
allow-java-serialization = off allow-java-serialization = off
serialize-messages = on serialize-messages = on
no-serialization-verification-needed-class-prefix = [] 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( val bootstrapSettings = BootstrapSetup(
None, None,
Some(ConfigFactory.parseString(""" Some(ConfigFactory.parseString("""
akka { pekko {
actor { actor {
allow-java-serialization = on allow-java-serialization = on
@ -74,7 +74,7 @@ object SerializationSetupSpec {
val noJavaSerializationSystem = ActorSystem( val noJavaSerializationSystem = ActorSystem(
"SerializationSettingsSpec" + "NoJavaSerialization", "SerializationSettingsSpec" + "NoJavaSerialization",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka { pekko {
actor { actor {
allow-java-serialization = off allow-java-serialization = off
# this is by default on, but tests are running with off, use defaults here # 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 { "fail during ActorSystem creation when misconfigured" in {
val config = val config =
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.loglevel = OFF pekko.loglevel = OFF
akka.stdout-loglevel = OFF pekko.stdout-loglevel = OFF
akka.actor.serializers.doe = "john.is.not.here" pekko.actor.serializers.doe = "john.is.not.here"
""").withFallback(ConfigFactory.load()) """).withFallback(ConfigFactory.load())
a[ClassNotFoundException] should be thrownBy { a[ClassNotFoundException] should be thrownBy {
@ -142,7 +142,7 @@ class SerializationSetupSpec
val addedJavaSerializationProgramaticallyButDisabledSettings = BootstrapSetup( val addedJavaSerializationProgramaticallyButDisabledSettings = BootstrapSetup(
None, None,
Some(ConfigFactory.parseString(""" Some(ConfigFactory.parseString("""
akka { pekko {
loglevel = debug loglevel = debug
actor { actor {
allow-java-serialization = off allow-java-serialization = off
@ -163,7 +163,7 @@ class SerializationSetupSpec
"throw if passed system to JavaSerializer has allow-java-serialization = off" in { "throw if passed system to JavaSerializer has allow-java-serialization = off" in {
intercept[DisabledJavaSerializer.JavaSerializationException] { intercept[DisabledJavaSerializer.JavaSerializationException] {
new JavaSerializer(noJavaSerializationSystem.asInstanceOf[ExtendedActorSystem]) 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] { intercept[DisabledJavaSerializer.JavaSerializationException] {
SerializationExtension(addedJavaSerializationViaSettingsSystem) 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 { object SerializationTests {
val serializeConf = s""" val serializeConf = s"""
akka { pekko {
actor { actor {
serializers { serializers {
test = "org.apache.pekko.serialization.NoopSerializer" test = "org.apache.pekko.serialization.NoopSerializer"
@ -92,7 +92,7 @@ object SerializationTests {
} }
val verifySerializabilityConf = """ val verifySerializabilityConf = """
akka { pekko {
actor { actor {
serialize-messages = on serialize-messages = on
serialize-creators = on serialize-creators = on
@ -128,8 +128,8 @@ object SerializationTests {
val referenceConf = ConfigFactory.defaultReference() val referenceConf = ConfigFactory.defaultReference()
val conf = ConfigFactory val conf = ConfigFactory
.parseString(""" .parseString("""
akka.actor.warn-about-java-serializer-usage = on pekko.actor.warn-about-java-serializer-usage = on
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
""") """)
.withFallback(ConfigFactory.parseString(serializeConf)) .withFallback(ConfigFactory.parseString(serializeConf))
.withFallback(AkkaSpec.testConf.withFallback(referenceConf)) .withFallback(AkkaSpec.testConf.withFallback(referenceConf))
@ -137,7 +137,7 @@ object SerializationTests {
} }
val systemMessageMultiSerializerConf = """ val systemMessageMultiSerializerConf = """
akka { pekko {
actor { actor {
serializers { serializers {
test = "org.apache.pekko.serialization.NoopSerializer" test = "org.apache.pekko.serialization.NoopSerializer"
@ -277,7 +277,7 @@ class SerializeSpec extends AkkaSpec(SerializationTests.serializeConf) {
val sys = ActorSystem( val sys = ActorSystem(
"SerializeSpec", "SerializeSpec",
ConfigFactory.parseString(s""" ConfigFactory.parseString(s"""
akka { pekko {
actor { actor {
serializers { serializers {
test = "org.apache.pekko.serialization.NoopSerializer" test = "org.apache.pekko.serialization.NoopSerializer"
@ -504,9 +504,9 @@ class AllowJavaSerializationSpec extends AkkaSpec(SerializationTests.allowJavaSe
class NoVerificationWarningSpec class NoVerificationWarningSpec
extends AkkaSpec(ConfigFactory.parseString(""" extends AkkaSpec(ConfigFactory.parseString("""
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = on pekko.actor.warn-about-java-serializer-usage = on
akka.actor.warn-on-no-serialization-verification = on pekko.actor.warn-on-no-serialization-verification = on
""")) { """)) {
val ser = SerializationExtension(system) val ser = SerializationExtension(system)
@ -530,9 +530,9 @@ class NoVerificationWarningSpec
class NoVerificationWarningOffSpec class NoVerificationWarningOffSpec
extends AkkaSpec(ConfigFactory.parseString(""" extends AkkaSpec(ConfigFactory.parseString("""
akka.actor.allow-java-serialization = on pekko.actor.allow-java-serialization = on
akka.actor.warn-about-java-serializer-usage = on pekko.actor.warn-about-java-serializer-usage = on
akka.actor.warn-on-no-serialization-verification = off pekko.actor.warn-on-no-serialization-verification = off
""")) { """)) {
val ser = SerializationExtension(system) val ser = SerializationExtension(system)
@ -563,7 +563,7 @@ class SerializerDeadlockSpec extends AkkaSpec {
val sys = ActorSystem( val sys = ActorSystem(
"SerializerDeadlockSpec", "SerializerDeadlockSpec",
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka { pekko {
actor { actor {
creation-timeout = 1s creation-timeout = 1s
serializers { 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 @ClassRule
public static final TestKitJunitResource testKit = public static final TestKitJunitResource testKit =
new TestKitJunitResource("akka.loglevel = off"); new TestKitJunitResource("pekko.loglevel = off");
@Rule public final LogCapturing logCapturing = new LogCapturing(); @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) { private HelloWorldMain(ActorContext<SayHello> context) {
super(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); Props greeterProps = DispatcherSelector.fromConfig(dispatcherPath);
greeter = getContext().spawn(HelloWorld.create(), "greeter", greeterProps); 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() { public void loadJavaExtensionsFromConfig() {
Config cfg = Config cfg =
ConfigFactory.parseString( 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(); .resolve();
final ActorSystem<Object> system = final ActorSystem<Object> system =
ActorSystem.create(Behaviors.empty(), "loadJavaExtensionsFromConfig", cfg); 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 = public static final TestKitJunitResource testKit =
new TestKitJunitResource( new TestKitJunitResource(
ConfigFactory.parseString( ConfigFactory.parseString(
"akka.loglevel = INFO\n" "pekko.loglevel = INFO\n"
+ "akka.loggers = [\"org.apache.pekko.testkit.TestEventListener\"]")); + "pekko.loggers = [\"org.apache.pekko.testkit.TestEventListener\"]"));
interface Protocol { interface Protocol {
String getTransactionId(); 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]] = val withDefault: Future[ActorRef[WhichDispatcher]] =
actor.ask(Spawn(giveMeYourDispatcher, "default", Props.empty, _)) actor.ask(Spawn(giveMeYourDispatcher, "default", Props.empty, _))
withDefault.futureValue ! WhichDispatcher(probe.ref) 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]] = val withBlocking: Future[ActorRef[WhichDispatcher]] =
actor.ask(Spawn(giveMeYourDispatcher, "default", DispatcherSelector.blocking(), _)) actor.ask(Spawn(giveMeYourDispatcher, "default", DispatcherSelector.blocking(), _))
withBlocking.futureValue ! WhichDispatcher(probe.ref) 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]] = val withCustom: Future[ActorRef[WhichDispatcher]] =
actor.ask(Spawn(giveMeYourDispatcher, "default", DispatcherSelector.fromConfig("your-dispatcher"), _)) 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") @nowarn("msg=never used")
class FaultToleranceDocSpec extends ScalaTestWithActorTestKit(""" class FaultToleranceDocSpec extends ScalaTestWithActorTestKit("""
# silenced to not put noise in test logs # silenced to not put noise in test logs
akka.loglevel = off pekko.loglevel = off
""") with AnyWordSpecLike { """) with AnyWordSpecLike {
import FaultToleranceDocSpec._ 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 // #hello-world-main-with-dispatchers
def apply(): Behavior[SayHello] = def apply(): Behavior[SayHello] =
Behaviors.setup { context => 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 props = DispatcherSelector.fromConfig(dispatcherPath)
val greeter = context.spawn(HelloWorld(), "greeter", props) 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 // 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._ import RouterSpec._
"The routing sample" must { "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 { object ExtensionDocSpec {
val config = ConfigFactory.parseString(""" val config = ConfigFactory.parseString("""
#config #config
akka.actor.typed.extensions = ["org.apache.pekko.akka.extensions.DatabasePool"] pekko.actor.typed.extensions = ["org.apache.pekko.pekko.extensions.DatabasePool"]
#config #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(""" class AskSpec extends ScalaTestWithActorTestKit("""
akka.loglevel=DEBUG pekko.loglevel=DEBUG
akka.actor.debug.event-stream = on pekko.actor.debug.event-stream = on
""") with AnyWordSpecLike with LogCapturing { """) with AnyWordSpecLike with LogCapturing {
import AskSpec._ 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 { object ExtensionsSpec {
val config = ConfigFactory.parseString(""" val config = ConfigFactory.parseString("""
akka.actor.typed { pekko.actor.typed {
library-extensions += "org.apache.pekko.actor.typed.InstanceCountingExtension" library-extensions += "org.apache.pekko.actor.typed.InstanceCountingExtension"
} }
""").resolve() """).resolve()
@ -115,7 +115,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Some( Some(
ConfigFactory.parseString( 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 =>
sys.hasExtension(DummyExtension1) should ===(true) sys.hasExtension(DummyExtension1) should ===(true)
sys.extension(DummyExtension1) shouldBe a[DummyExtension1] sys.extension(DummyExtension1) shouldBe a[DummyExtension1]
@ -130,7 +130,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Behaviors.empty[Any], Behaviors.empty[Any],
"ExtensionsSpec04", "ExtensionsSpec04",
ConfigFactory.parseString(""" 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 "allow for auto-loading of library-extensions" in
withEmptyActorSystem("ExtensionsSpec06") { sys => 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 listedExtensions.size should be > 0
// could be initialized by other tests, so at least once // could be initialized by other tests, so at least once
InstanceCountingExtension.createCount.get() should be > 0 InstanceCountingExtension.createCount.get() should be > 0
@ -167,7 +167,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
"ExtensionsSpec07", "ExtensionsSpec07",
Some( Some(
ConfigFactory.parseString( 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( withEmptyActorSystem(
"ExtensionsSpec08", "ExtensionsSpec08",
Some(ConfigFactory.parseString( 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( Some(
ConfigFactory.parseString( 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 => Some(ActorSystemSetup(new DummyExtension1Setup(_ => new DummyExtension1ViaSetup)))) { sys =>
sys.hasExtension(DummyExtension1) should ===(true) sys.hasExtension(DummyExtension1) should ===(true)
@ -248,7 +248,7 @@ class ExtensionsSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
Some( Some(
ConfigFactory.parseString( ConfigFactory.parseString(
""" """
akka.actor.typed.extensions = ["org.apache.pekko.actor.typed.AccessSystemFromConstructorExtensionId$"] pekko.actor.typed.extensions = ["org.apache.pekko.actor.typed.AccessSystemFromConstructorExtensionId$"]
""")), """)),
None) { sys => None) { sys =>
AccessSystemFromConstructorExtensionId(sys) // would throw if it couldn't 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 { object LocalActorRefProviderLogMessagesSpec {
val config = """ val config = """
akka { pekko {
loglevel = DEBUG # test verifies debug loglevel = DEBUG # test verifies debug
log-dead-letters = on log-dead-letters = on
actor { 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._ import pekko.actor.typed.scaladsl.adapter._
class LogMessagesSpec extends ScalaTestWithActorTestKit(""" class LogMessagesSpec extends ScalaTestWithActorTestKit("""
akka.loglevel = DEBUG # test verifies debug pekko.loglevel = DEBUG # test verifies debug
""") with AnyWordSpecLike with LogCapturing { """) with AnyWordSpecLike with LogCapturing {
implicit val classic: actor.ActorSystem = system.toClassic 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(""" class SupervisionSpec extends ScalaTestWithActorTestKit("""
akka.log-dead-letters = off pekko.log-dead-letters = off
""") with AnyWordSpecLike with LogCapturing { """) with AnyWordSpecLike with LogCapturing {
import BehaviorInterceptor._ 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( val classicSystem = pekko.actor.ActorSystem(
"ClassicSupervisingTypedSpec", "ClassicSupervisingTypedSpec",
ConfigFactory.parseString(""" 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) val classicTestKit = new pekko.testkit.TestKit(classicSystem)
implicit val classicSender: u.ActorRef = classicTestKit.testActor 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(""" class TypedSupervisingClassicSpec extends ScalaTestWithActorTestKit("""
akka.loglevel = INFO pekko.loglevel = INFO
""".stripMargin) with AnyWordSpecLike with LogCapturing { """.stripMargin) with AnyWordSpecLike with LogCapturing {
import TypedSupervisingClassicSpec._ 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 class ConsumerControllerSpec
extends ScalaTestWithActorTestKit(ConfigFactory.parseString(""" extends ScalaTestWithActorTestKit(ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller { pekko.reliable-delivery.consumer-controller {
flow-control-window = 20 flow-control-window = 20
resend-interval-min = 1s 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 class DurableProducerControllerSpec
extends ScalaTestWithActorTestKit( extends ScalaTestWithActorTestKit(
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20 pekko.reliable-delivery.consumer-controller.flow-control-window = 20
akka.reliable-delivery.consumer-controller.resend-interval-min = 1s pekko.reliable-delivery.consumer-controller.resend-interval-min = 1s
""").withFallback(TestSerializer.config)) """).withFallback(TestSerializer.config))
with AnyWordSpecLike with AnyWordSpecLike
with LogCapturing { 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 class DurableWorkPullingSpec
extends ScalaTestWithActorTestKit(""" extends ScalaTestWithActorTestKit("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20 pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""") """)
with AnyWordSpecLike with AnyWordSpecLike
with LogCapturing { 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 class ProducerControllerSpec
extends ScalaTestWithActorTestKit( extends ScalaTestWithActorTestKit(
ConfigFactory.parseString(""" ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20 pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""").withFallback(TestSerializer.config)) """).withFallback(TestSerializer.config))
with AnyWordSpecLike with AnyWordSpecLike
with LogCapturing { 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 { object ReliableDeliveryRandomSpec {
val config: Config = ConfigFactory.parseString(""" val config: Config = ConfigFactory.parseString("""
akka.reliable-delivery.consumer-controller { pekko.reliable-delivery.consumer-controller {
flow-control-window = 20 flow-control-window = 20
resend-interval-min = 500 ms resend-interval-min = 500 ms
resend-interval-max = 2 s resend-interval-max = 2 s
@ -215,5 +215,5 @@ class ReliableDeliveryRandomSpec(config: Config)
class ReliableDeliveryRandomChunkedSpec class ReliableDeliveryRandomChunkedSpec
extends ReliableDeliveryRandomSpec( extends ReliableDeliveryRandomSpec(
ConfigFactory.parseString(""" 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)) """).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 { object ReliableDeliverySpec {
val config: Config = ConfigFactory.parseString(""" 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 class ReliableDeliveryChunkedSpec
extends ReliableDeliverySpec( extends ReliableDeliverySpec(
ConfigFactory.parseString(""" 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)) """).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 { object TestSerializer {
val config: Config = ConfigFactory.parseString(s""" val config: Config = ConfigFactory.parseString(s"""
akka.actor.serializers.delivery-test = ${classOf[TestSerializer].getName} pekko.actor.serializers.delivery-test = ${classOf[TestSerializer].getName}
akka.actor.serialization-bindings { pekko.actor.serialization-bindings {
"${classOf[TestConsumer.Job].getName}" = delivery-test "${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 class WorkPullingSpec
extends ScalaTestWithActorTestKit(""" extends ScalaTestWithActorTestKit("""
akka.reliable-delivery.consumer-controller.flow-control-window = 20 pekko.reliable-delivery.consumer-controller.flow-control-window = 20
""") """)
with AnyWordSpecLike with AnyWordSpecLike
with LogCapturing { with LogCapturing {

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