org.apache.pekko.http.impl.engine.ws

Class WSClientAutobahnTest

java.lang.Object

org.apache.pekko.http.impl.engine.ws.WSClientAutobahnTest

public class WSClientAutobahnTest
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	WSClientAutobahnTest.CaseInfo
static class	WSClientAutobahnTest.CaseInfo$
static class	WSClientAutobahnTest.CaseResult
static class	WSClientAutobahnTest.CaseResult$
static class	WSClientAutobahnTest.CaseStatus
static class	WSClientAutobahnTest.CaseStatus$
static class	WSClientAutobahnTest.IndexedCaseInfo
static class	WSClientAutobahnTest.IndexedCaseInfo$

Constructor Summary

Constructors

Constructor and Description
WSClientAutobahnTest()

Method Summary

Modifier and Type	Method and Description
static java.lang.String	Agent()
protected static java.lang.String[]	args()
static <T> scala.Function1<scala.util.Try<T>,scala.runtime.BoxedUnit>	completion()
static <T> org.apache.pekko.stream.scaladsl.Flow<T,T,scala.concurrent.Future<org.apache.pekko.Done>>	completionSignal()
static void	delayedInit(scala.Function0<scala.runtime.BoxedUnit> body)
static org.apache.pekko.stream.scaladsl.Flow<Message,Message,scala.concurrent.Future<org.apache.pekko.Done>>	echo()
static long	executionStart()
static scala.concurrent.Future<java.lang.Object>	getCaseCount()
static Uri	getCaseCountUri()
static scala.concurrent.Future<WSClientAutobahnTest.IndexedCaseInfo>	getCaseInfo(int caseId)
static Uri	getCaseInfoUri(int caseIndex)
static scala.concurrent.Future<scala.collection.immutable.Map<java.lang.String,WSClientAutobahnTest.IndexedCaseInfo>>	getCaseMap() Map from textual case ID (like 1.1.1) to IndexedCaseInfo
static scala.concurrent.Future<WSClientAutobahnTest.CaseStatus>	getCaseStatus(int caseId, java.lang.String agent)
static Uri	getCaseStatusUri(int caseIndex, java.lang.String agent)
static void	main(java.lang.String[] args)
static int	Parallelism()
static scala.concurrent.Future<WSClientAutobahnTest.CaseResult>	richRunCase(int caseIndex, java.lang.String agent)
static scala.concurrent.Future<WSClientAutobahnTest.CaseStatus>	runCase(int caseIndex, java.lang.String agent)
static Uri	runCaseUri(int caseIndex, java.lang.String agent)
static <T> scala.concurrent.Future<T>	runToSingleJsonValue(Uri uri, spray.json.JsonReader<T> evidence$1)
static scala.concurrent.Future<java.lang.String>	runToSingleText(Uri uri) The autobahn tests define a weird API where every request must be a WebSocket request and they will send a single websocket message with the result.
static <T> T	runWs(Uri uri, org.apache.pekko.stream.scaladsl.Flow<Message,Message,T> clientFlow)
protected abstract static void	scala$App$_setter_$executionStart_$eq(long x$1)
protected abstract static void	scala$App$_setter_$scala$App$$initCode_$eq(scala.collection.mutable.ListBuffer<scala.Function0<scala.runtime.BoxedUnit>> x$1)
static void	scala$App$$_args_$eq(java.lang.String[] x$1)
static java.lang.String[]	scala$App$$_args()
static scala.collection.mutable.ListBuffer<scala.Function0<scala.runtime.BoxedUnit>>	scala$App$$initCode()
static org.apache.pekko.actor.ActorSystem	system()
static scala.concurrent.Future<scala.runtime.BoxedUnit>	updateReports(java.lang.String agent)
static void	updateReportsAndShutdown()
static Uri	updateReportsUri(java.lang.String agent)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

WSClientAutobahnTest

public WSClientAutobahnTest()

Method Detail

executionStart

public static final long executionStart()

system

public static org.apache.pekko.actor.ActorSystem system()

Agent

public static java.lang.String Agent()

Parallelism

public static int Parallelism()

getCaseCountUri

public static Uri getCaseCountUri()

runCaseUri

public static Uri runCaseUri(int caseIndex,
                             java.lang.String agent)

getCaseStatusUri

public static Uri getCaseStatusUri(int caseIndex,
                                   java.lang.String agent)

getCaseInfoUri

public static Uri getCaseInfoUri(int caseIndex)

updateReportsUri

public static Uri updateReportsUri(java.lang.String agent)

runCase

public static scala.concurrent.Future<WSClientAutobahnTest.CaseStatus> runCase(int caseIndex,
                                                                               java.lang.String agent)

richRunCase

public static scala.concurrent.Future<WSClientAutobahnTest.CaseResult> richRunCase(int caseIndex,
                                                                                   java.lang.String agent)

getCaseCount

public static scala.concurrent.Future<java.lang.Object> getCaseCount()

getCaseInfo

public static scala.concurrent.Future<WSClientAutobahnTest.IndexedCaseInfo> getCaseInfo(int caseId)

getCaseStatus

public static scala.concurrent.Future<WSClientAutobahnTest.CaseStatus> getCaseStatus(int caseId,
                                                                                     java.lang.String agent)

updateReports

public static scala.concurrent.Future<scala.runtime.BoxedUnit> updateReports(java.lang.String agent)

getCaseMap

public static scala.concurrent.Future<scala.collection.immutable.Map<java.lang.String,WSClientAutobahnTest.IndexedCaseInfo>> getCaseMap()

Map from textual case ID (like 1.1.1) to IndexedCaseInfo

Returns:

echo

public static org.apache.pekko.stream.scaladsl.Flow<Message,Message,scala.concurrent.Future<org.apache.pekko.Done>> echo()

completion

public static <T> scala.Function1<scala.util.Try<T>,scala.runtime.BoxedUnit> completion()

updateReportsAndShutdown

public static void updateReportsAndShutdown()

runWs

public static <T> T runWs(Uri uri,
                          org.apache.pekko.stream.scaladsl.Flow<Message,Message,T> clientFlow)

completionSignal

public static <T> org.apache.pekko.stream.scaladsl.Flow<T,T,scala.concurrent.Future<org.apache.pekko.Done>> completionSignal()

runToSingleText

public static scala.concurrent.Future<java.lang.String> runToSingleText(Uri uri)

The autobahn tests define a weird API where every request must be a WebSocket request and they will send a single websocket message with the result. WebSocket everywhere? Strange, but somewhat consistent.

Parameters:

uri - (undocumented)

Returns:

(undocumented)

runToSingleJsonValue

public static <T> scala.concurrent.Future<T> runToSingleJsonValue(Uri uri,
                                                                  spray.json.JsonReader<T> evidence$1)

args

protected static final java.lang.String[] args()

scala$App$$_args

public static java.lang.String[] scala$App$$_args()

scala$App$$_args_$eq

public static void scala$App$$_args_$eq(java.lang.String[] x$1)

scala$App$$initCode

public static scala.collection.mutable.ListBuffer<scala.Function0<scala.runtime.BoxedUnit>> scala$App$$initCode()

delayedInit

public static void delayedInit(scala.Function0<scala.runtime.BoxedUnit> body)

main

public static final void main(java.lang.String[] args)

scala$App$_setter_$executionStart_$eq

protected abstract static void scala$App$_setter_$executionStart_$eq(long x$1)

scala$App$_setter_$scala$App$$initCode_$eq

protected abstract static void scala$App$_setter_$scala$App$$initCode_$eq(scala.collection.mutable.ListBuffer<scala.Function0<scala.runtime.BoxedUnit>> x$1)