| An exception or error caused a run to abort: akka.actor.ActorSystem.shutdown()V | |
| java.lang.NoSuchMethodError: akka.actor.ActorSystem.shutdown()V | |
| at org.apache.flink.runtime.minicluster.FlinkMiniCluster$$anonfun$startInternalShutdown$5$$anonfun$apply$7.apply(FlinkMiniCluster.scala:483) | |
| at org.apache.flink.runtime.minicluster.FlinkMiniCluster$$anonfun$startInternalShutdown$5$$anonfun$apply$7.apply(FlinkMiniCluster.scala:483) | |
| at scala.collection.Iterator$class.foreach(Iterator.scala:893) | |
| at scala.collection.AbstractIterator.foreach(Iterator.scala:1336) | |
| at scala.collection.IterableLike$class.foreach(IterableLike.scala:72) | |
| at scala.collection.AbstractIterable.foreach(Iterable.scala:54) | |
| at org.apache.flink.runtime.minicluster.FlinkMiniCluster$$anonfun$startInternalShutdown$5.apply(FlinkMiniCluster.scala:483) |
| trait FromSlice[C] { | |
| def apply(v: C): Int | |
| } | |
| def tupleSlice[T] = new FromSlice[Tuple[T]] { | |
| def apply(v: Tuple[T]): Int = v.size | |
| } | |
| // ... Same for Either and other |
| { | |
| "uuid": "test", | |
| "source": {same}, | |
| "sink": { | |
| "jdbcUrl": "jdbc:postgresql://192.168.1.249:5433/mwm?stringtype=unspecified", | |
| "tableName": "sm_events_sink_test", | |
| "rowSchema": { | |
| "fromTime": ["fromTs", "first(toTs(datetime))"], | |
| "toTime": ["toTs", "last(toTs(datetime))"], | |
| "payload": { |
| case class FunctionNPhase[Event, States <: HList, Phases <: HList]( | |
| function: Seq[Double] => Double, | |
| functionName: String, | |
| innerPhases: Phases | |
| )(implicit ev: Mapped.Aux[States, ({ type T[State] = NumericPhaseParser[Event, State] })#T, Phases]) | |
| extends Pattern[Event, States, Double] { | |
| private val initialStateGetter = new (({ type U[State] = NumericPhaseParser[Event, State] })#U ~> Id) { | |
| override def apply[T](f: NumericPhaseParser[Event, T]): Id[T] = f.initialState | |
| } |
| trait StreamAlg[S[_], KeyedS[_], InEvent] { | |
| def createStream: S[InEvent] | |
| def keyBy[E](stream: S[E]): KeyedS[E] | |
| def flatMapWithState[InE, OutE, State](stream: S[InE])(f: (InE, State) => Seq[OutE]): S[OutE] | |
| def mapWithState[InE, OutE, State](stream: S[InE])(f: (InE, State) => Seq[OutE]): S[OutE] |
| [error] java.lang.NoSuchMethodError: scala.reflect.api.Internals$ReificationSupportApi.SyntacticTypeApplied()Lscala/reflect/api/Internals$Reifi$$$$9694e45bc19be932a29ce44fb2993611$$$$ppliedExtractor; | |
| [error] at tapir.generic.FormCodecMacros$.$anonfun$generateForCaseClass$1(FormCodecDerivation.scala:24) | |
| [error] at scala.collection.immutable.List.map(List.scala:286) | |
| [error] at tapir.generic.FormCodecMacros$.generateForCaseClass(FormCodecDerivation.scala:23) | |
| [error] at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) | |
| [error] at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) | |
| [error] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) | |
| [error] at java.lang.reflect.Method.invoke(Method.java:498) | |
| [error] at scala.reflect.macros.runtime.JavaReflectionRuntimes$JavaReflectionResolvers.$anonfun$resolveJavaReflectionRuntime$4(JavaReflectionRuntimes.scala:46) | |
| [error] at scal |
| class T extends WordSpec with FridaDefaultJsonProtocol with Directives with SprayJsonSupport with Matchers with ScalatestRouteTest { | |
| import scala.concurrent.ExecutionContext.Implicits.global | |
| Kamon.addReporter(new InfluxDBReporter(Kamon.config())) | |
| private val log = LoggerFactory.getLogger(getClass.getName) | |
| val futureFunc: Future[Int] = Future(123) | |
| val eHandler = ExceptionHandler { |
| sealed trait Slice extends Product with Serializable { | |
| def length: Int | |
| } | |
| object Slice { | |
| def empty: Slice = EmptySlice | |
| } | |
| case class HalfSlice(num: Int, ind: Int) extends Slice { | |
| override def length = 1 | |
| } |
| def maxRun(a: Array[Int]): Int = if (a.length < 2) a.length else { | |
| val (totalMaxRun, (prevRun, _)) = a.tail.foldLeft(1 -> (1, a.head)) { | |
| case ((maxRun, (currRun, prevNum)), currNum) if Math.abs(currNum - prevNum) == 1 => | |
| Math.max(maxRun, currRun + 1) -> (currRun + 1, currNum) | |
| // currNum doesn't belongs to currRun | |
| case ((maxRun, (currRun, prevNum)), currNum) => Math.max(maxRun, currRun) -> (1, currNum) | |
| } | |
| Math.max(totalMaxRun, prevRun) | |
| } |